Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4283 anupam.sin 318 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
321 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
3064 chandransh 330 
     - imeiNumber
331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
339 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
340 
    """
341 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 342 
    given warehouse and were picked up by the given provider as MANIFESTED.
343 
 
344 
    Parameters:
345 
     - warehouseId
346 
     - providerId
347 
     - cod
348 
    """
349 
    pass
350 
 
351 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 354 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 355 
 
3064 chandransh 356 
    Parameters:
759 chandransh 357 
     - warehouseId
358 
     - providerId
3064 chandransh 359 
     - cod
759 chandransh 360 
    """
361 
    pass
362 
 
1113 chandransh 363 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
364 
    """
365 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
366 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
367 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 368 
 
1113 chandransh 369 
    Parameters:
370 
     - providerId
371 
     - pickupDetails
372 
    """
373 
    pass
374 
 
1132 chandransh 375 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
376 
    """
377 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
378 
    the name of the receiver.
379 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 380 
 
1132 chandransh 381 
    Parameters:
382 
     - providerId
383 
     - deliveredOrders
384 
    """
385 
    pass
386 
 
1135 chandransh 387 
  def markOrdersAsFailed(self, providerId, returnedOrders):
388 
    """
389 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
390 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 391 
 
1135 chandransh 392 
    Parameters:
393 
     - providerId
394 
     - returnedOrders
395 
    """
396 
    pass
397 
 
1246 chandransh 398 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
399 
    """
400 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 401 
 
1246 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - undeliveredOrders
405 
    """
406 
    pass
407 
 
1408 ankur.sing 408 
  def getUndeliveredOrders(self, providerId, warehouseId):
409 
    """
410 
    Returns the list of orders whose delivery time has passed but have not been
411 
    delivered yet for the given provider and warehouse. To get a complete list of
412 
    undelivered orders, pass them as -1.
413 
    Returns an empty list if no such orders exist.
3431 rajveer 414 
 
1408 ankur.sing 415 
    Parameters:
416 
     - providerId
417 
     - warehouseId
418 
    """
419 
    pass
420 
 
2536 chandransh 421 
  def toggleDOAFlag(self, orderId):
422 
    """
423 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
424 
    Returns the final flag status.
425 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 426 
 
2536 chandransh 427 
    Parameters:
428 
     - orderId
429 
    """
430 
    pass
1886 ankur.sing 431 
 
4454 rajveer 432 
  def markOrderDoaRequestReceived(self, orderId):
433 
    """
434 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
435 
 
436 
    Parameters:
437 
     - orderId
438 
    """
439 
    pass
440 
 
441 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
442 
    """
443 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
444 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
445 
 
446 
    Parameters:
447 
     - orderId
448 
     - isAuthorized
449 
    """
450 
    pass
451 
 
2536 chandransh 452 
  def requestPickupNumber(self, orderId):
453 
    """
454 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 455 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
456 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 457 
    For any other status, it returns false.
458 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 459 
 
2536 chandransh 460 
    Parameters:
461 
     - orderId
462 
    """
463 
    pass
464 
 
465 
  def authorizePickup(self, orderId, pickupNumber):
466 
    """
4452 rajveer 467 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 468 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
469 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
470 
    	3. Returns true
2591 chandransh 471 
    If the order is in any other status, it returns false.
2536 chandransh 472 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 473 
 
2536 chandransh 474 
    Parameters:
475 
     - orderId
476 
     - pickupNumber
477 
    """
478 
    pass
479 
 
2764 chandransh 480 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
481 
    """
482 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
483 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 484 
 
2764 chandransh 485 
    Parameters:
486 
     - providerId
487 
     - pickupDetails
488 
    """
489 
    pass
490 
 
4479 rajveer 491 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 492 
    """
4452 rajveer 493 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
2616 chandransh 494 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 495 
    If the order is in any other state, it returns false.
496 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 497 
 
2591 chandransh 498 
    Parameters:
499 
     - orderId
4479 rajveer 500 
     - receiveCondition
2591 chandransh 501 
    """
502 
    pass
2536 chandransh 503 
 
2591 chandransh 504 
  def validateDoa(self, orderId, isValid):
505 
    """
4452 rajveer 506 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 507 
    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 508 
    If the order is in any other state, it returns false.
509 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 510 
 
2591 chandransh 511 
    Parameters:
512 
     - orderId
513 
     - isValid
514 
    """
515 
    pass
516 
 
2616 chandransh 517 
  def reshipOrder(self, orderId):
518 
    """
519 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
520 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
521 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
522 
 
523 
    If the order is in DOA_CERT_VALID state, it does the following:
524 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
525 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 526 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 527 
 
2616 chandransh 528 
    Returns the id of the newly created order.
3431 rajveer 529 
 
2616 chandransh 530 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 531 
 
2616 chandransh 532 
    Parameters:
533 
     - orderId
534 
    """
535 
    pass
2591 chandransh 536 
 
3226 chandransh 537 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 538 
    """
539 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
540 
    	1. Creates a refund request for batch processing.
541 
    	2. Creates a return order for the warehouse executive to return the shipped material.
542 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 543 
 
2616 chandransh 544 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
545 
    	1. Creates a refund request for batch processing.
3226 chandransh 546 
    	2. Cancels the reservation of the item in the warehouse.
547 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 548 
 
3226 chandransh 549 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
550 
    	1. Cancels the reservation of the item in the warehouse.
551 
    	2. Marks the current order as CANCELED.
552 
 
553 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
554 
 
2616 chandransh 555 
    Returns True if it is successful, False otherwise.
3431 rajveer 556 
 
2616 chandransh 557 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 558 
 
2616 chandransh 559 
    Parameters:
560 
     - orderId
3226 chandransh 561 
     - refundedBy
562 
     - reason
2616 chandransh 563 
    """
564 
    pass
565 
 
2690 chandransh 566 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
567 
    """
568 
    Get all return orders created between the from and to dates for the given warehouse.
569 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 570 
 
2690 chandransh 571 
    Parameters:
572 
     - warehouseId
573 
     - fromDate
574 
     - toDate
575 
    """
576 
    pass
2616 chandransh 577 
 
2700 chandransh 578 
  def getReturnOrder(self, id):
579 
    """
580 
    Returns the ReturnOrder corresponding to the given id.
581 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 582 
 
2700 chandransh 583 
    Parameters:
584 
     - id
585 
    """
586 
    pass
587 
 
2690 chandransh 588 
  def processReturn(self, returnOrderId):
589 
    """
590 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 591 
 
2690 chandransh 592 
    Parameters:
593 
     - returnOrderId
594 
    """
595 
    pass
596 
 
2819 chandransh 597 
  def createPurchaseOrder(self, warehouseId):
598 
    """
599 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 600 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 601 
 
2819 chandransh 602 
    Parameters:
603 
     - warehouseId
604 
    """
605 
    pass
2690 chandransh 606 
 
3451 chandransh 607 
  def updateWeight(self, orderId, weight):
608 
    """
609 
    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 610 
 
3451 chandransh 611 
    Parameters:
612 
     - orderId
613 
     - weight
614 
    """
615 
    pass
616 
 
3469 chandransh 617 
  def changeItem(self, orderId, itemId):
618 
    """
619 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
620 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 621 
 
3469 chandransh 622 
    Parameters:
623 
     - orderId
624 
     - itemId
625 
    """
626 
    pass
627 
 
628 
  def shiftToWarehouse(self, orderId, warehouseId):
629 
    """
630 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
631 
 
632 
    Parameters:
633 
     - orderId
634 
     - warehouseId
635 
    """
636 
    pass
637 
 
3986 chandransh 638 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 639 
    """
640 
    Adds the given delay reason to the given order.
3986 chandransh 641 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 642 
    Raises an exception if no order with the given id can be found.
3469 chandransh 643 
 
3553 chandransh 644 
    Parameters:
645 
     - orderId
646 
     - delayReason
3986 chandransh 647 
     - furtherDelay
3553 chandransh 648 
    """
649 
    pass
650 
 
3956 chandransh 651 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
652 
    """
653 
    Marks the COD orders with given AWB nos. as having been processed.
654 
    Updates the captured amount for the corresponding payment.
3553 chandransh 655 
 
3956 chandransh 656 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
657 
    1. There is no order corresponding to an AWB number.
658 
    2. The captured amount for a payment exceeds the total payment.
659 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
660 
 
661 
    Parameters:
662 
     - collectedAmountMap
663 
     - xferBy
664 
     - xferTxnId
665 
     - xferDate
666 
    """
667 
    pass
668 
 
4008 mandeep.dh 669 
  def getTransactionsRequiringExtraProcessing(self, category):
670 
    """
4065 mandeep.dh 671 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 672 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 673 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 674 
 
4008 mandeep.dh 675 
    Parameters:
676 
     - category
677 
    """
678 
    pass
679 
 
680 
  def markTransactionAsProcessed(self, transactionId, category):
681 
    """
682 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 683 
    It essentially deletes the transaction id record for a particular
684 
    processing type category (if present) from DB.
685 
    This is currently used by CRM application.
4008 mandeep.dh 686 
 
687 
    Parameters:
688 
     - transactionId
689 
     - category
690 
    """
691 
    pass
692 
 
4018 chandransh 693 
  def getItemWiseRiskyOrdersCount(self, ):
694 
    """
695 
    Returns a map containing the number of risky orders keyed by item id. A risky order
696 
    is defined as one whose shipping date is about to expire.
697 
    """
698 
    pass
4008 mandeep.dh 699 
 
4295 varun.gupt 700 
  def getOrdersForItemIds(self, itemIds):
701 
    """
702 
    Returns a list of all orders which have items with given id
703 
 
704 
    Parameters:
705 
     - itemIds
706 
    """
707 
    pass
708 
 
4247 rajveer 709 
  def markOrderCancellationRequestReceived(self, orderId):
710 
    """
711 
    Mark order as cancellation request received. If customer sends request of cancellation of
712 
    a particular order, this method will be called. It will just change status of the order
713 
    depending on its current status. It also records the previous status, so that we can move
714 
    back to that status if cancellation request is denied.
4018 chandransh 715 
 
4247 rajveer 716 
    Parameters:
717 
     - orderId
718 
    """
719 
    pass
720 
 
721 
  def markOrderCancellationRequestConfirmed(self, orderId):
722 
    """
723 
    If we decide to to cancel order, CRM will call this method to move the status of order to
724 
    cancellation request confirmed. After this OM will be able to cancel the order.
725 
 
726 
    Parameters:
727 
     - orderId
728 
    """
729 
    pass
730 
 
731 
  def markOrderCancellationRequestDenied(self, orderId):
732 
    """
733 
    If we decide to not to cancel order, we will move the order ro previous status.
734 
 
735 
    Parameters:
736 
     - orderId
737 
    """
738 
    pass
739 
 
4258 rajveer 740 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 741 
    """
4258 rajveer 742 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
743 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 744 
 
745 
    Parameters:
4258 rajveer 746 
     - transactionId
4247 rajveer 747 
    """
748 
    pass
749 
 
4259 anupam.sin 750 
  def refundTransaction(self, transactionId, refundedBy, reason):
751 
    """
752 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
753 
    need to be cancelled
4247 rajveer 754 
 
4259 anupam.sin 755 
    Parameters:
756 
     - transactionId
757 
     - refundedBy
758 
     - reason
759 
    """
760 
    pass
761 
 
4324 mandeep.dh 762 
  def updateShipmentAddress(self, orderId, addressId):
763 
    """
764 
    Updates shipment address of an order. Delivery and shipping date estimates
765 
    etc. are also updated here.
766 
 
767 
    Throws TransactionServiceException in case address change is not
768 
    possible due to certain reasons such as new pincode in address is
769 
    not serviceable etc.
770 
 
771 
    Parameters:
772 
     - orderId
773 
     - addressId
774 
    """
775 
    pass
776 
 
4285 rajveer 777 
  def acceptOrdersForItemId(self, itemId, inventory):
778 
    """
779 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
780 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 781 
 
4285 rajveer 782 
    Parameters:
783 
     - itemId
784 
     - inventory
785 
    """
786 
    pass
787 
 
4369 rajveer 788 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 789 
    """
790 
    Parameters:
791 
     - vendorId
792 
     - itemId
793 
     - quantity
794 
     - estimate
4369 rajveer 795 
     - isReminder
4303 rajveer 796 
    """
797 
    pass
4285 rajveer 798 
 
4369 rajveer 799 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 800 
    """
801 
    Parameters:
802 
     - vendorId
803 
     - itemId
804 
     - quantity
805 
     - estimate
4369 rajveer 806 
     - isReminder
4303 rajveer 807 
    """
808 
    pass
809 
 
4369 rajveer 810 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 811 
    """
812 
    Parameters:
813 
     - vendorId
814 
     - itemId
815 
     - quantity
816 
     - estimate
4369 rajveer 817 
     - isReminder
4303 rajveer 818 
    """
819 
    pass
820 
 
4369 rajveer 821 
  def markOrdersAsTimeout(self, vendorId):
822 
    """
823 
    Parameters:
824 
     - vendorId
825 
    """
826 
    pass
4303 rajveer 827 
 
4386 anupam.sin 828 
  def getOrderForAwb(self, awb):
829 
    """
830 
    Returns the order corresponding to an AWB number
4369 rajveer 831 
 
4386 anupam.sin 832 
    Parameters:
833 
     - awb
834 
    """
835 
    pass
836 
 
837 
 
3376 rajveer 838 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 839 
  def __init__(self, iprot, oprot=None):
3376 rajveer 840 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 841 
 
842 
  def createTransaction(self, transaction):
843 
    """
844 
    Parameters:
845 
     - transaction
846 
    """
847 
    self.send_createTransaction(transaction)
132 ashish 848 
    return self.recv_createTransaction()
94 ashish 849 
 
850 
  def send_createTransaction(self, transaction):
851 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
852 
    args = createTransaction_args()
853 
    args.transaction = transaction
854 
    args.write(self._oprot)
855 
    self._oprot.writeMessageEnd()
856 
    self._oprot.trans.flush()
857 
 
858 
  def recv_createTransaction(self, ):
859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
860 
    if mtype == TMessageType.EXCEPTION:
861 
      x = TApplicationException()
862 
      x.read(self._iprot)
863 
      self._iprot.readMessageEnd()
864 
      raise x
865 
    result = createTransaction_result()
866 
    result.read(self._iprot)
867 
    self._iprot.readMessageEnd()
3431 rajveer 868 
    if result.success is not None:
132 ashish 869 
      return result.success
3431 rajveer 870 
    if result.ex is not None:
94 ashish 871 
      raise result.ex
132 ashish 872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 873 
 
874 
  def getTransaction(self, id):
875 
    """
876 
    Parameters:
877 
     - id
878 
    """
879 
    self.send_getTransaction(id)
880 
    return self.recv_getTransaction()
881 
 
882 
  def send_getTransaction(self, id):
883 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
884 
    args = getTransaction_args()
885 
    args.id = id
886 
    args.write(self._oprot)
887 
    self._oprot.writeMessageEnd()
888 
    self._oprot.trans.flush()
889 
 
890 
  def recv_getTransaction(self, ):
891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
892 
    if mtype == TMessageType.EXCEPTION:
893 
      x = TApplicationException()
894 
      x.read(self._iprot)
895 
      self._iprot.readMessageEnd()
896 
      raise x
897 
    result = getTransaction_result()
898 
    result.read(self._iprot)
899 
    self._iprot.readMessageEnd()
3431 rajveer 900 
    if result.success is not None:
94 ashish 901 
      return result.success
3431 rajveer 902 
    if result.ex is not None:
94 ashish 903 
      raise result.ex
904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
905 
 
906 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
907 
    """
908 
    Parameters:
909 
     - customerId
910 
     - from_date
911 
     - to_date
912 
     - status
913 
    """
914 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
915 
    return self.recv_getTransactionsForCustomer()
916 
 
917 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
918 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
919 
    args = getTransactionsForCustomer_args()
920 
    args.customerId = customerId
921 
    args.from_date = from_date
922 
    args.to_date = to_date
923 
    args.status = status
924 
    args.write(self._oprot)
925 
    self._oprot.writeMessageEnd()
926 
    self._oprot.trans.flush()
927 
 
928 
  def recv_getTransactionsForCustomer(self, ):
929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
930 
    if mtype == TMessageType.EXCEPTION:
931 
      x = TApplicationException()
932 
      x.read(self._iprot)
933 
      self._iprot.readMessageEnd()
934 
      raise x
935 
    result = getTransactionsForCustomer_result()
936 
    result.read(self._iprot)
937 
    self._iprot.readMessageEnd()
3431 rajveer 938 
    if result.success is not None:
94 ashish 939 
      return result.success
3431 rajveer 940 
    if result.ex is not None:
94 ashish 941 
      raise result.ex
942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
943 
 
132 ashish 944 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
945 
    """
946 
    Parameters:
947 
     - shoppingCartId
948 
    """
949 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
950 
    return self.recv_getTransactionsForShoppingCartId()
951 
 
952 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
953 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
954 
    args = getTransactionsForShoppingCartId_args()
955 
    args.shoppingCartId = shoppingCartId
956 
    args.write(self._oprot)
957 
    self._oprot.writeMessageEnd()
958 
    self._oprot.trans.flush()
959 
 
960 
  def recv_getTransactionsForShoppingCartId(self, ):
961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
962 
    if mtype == TMessageType.EXCEPTION:
963 
      x = TApplicationException()
964 
      x.read(self._iprot)
965 
      self._iprot.readMessageEnd()
966 
      raise x
967 
    result = getTransactionsForShoppingCartId_result()
968 
    result.read(self._iprot)
969 
    self._iprot.readMessageEnd()
3431 rajveer 970 
    if result.success is not None:
132 ashish 971 
      return result.success
3431 rajveer 972 
    if result.ex is not None:
132 ashish 973 
      raise result.ex
974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
975 
 
94 ashish 976 
  def getTransactionStatus(self, transactionId):
977 
    """
978 
    Parameters:
979 
     - transactionId
980 
    """
981 
    self.send_getTransactionStatus(transactionId)
982 
    return self.recv_getTransactionStatus()
983 
 
984 
  def send_getTransactionStatus(self, transactionId):
985 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
986 
    args = getTransactionStatus_args()
987 
    args.transactionId = transactionId
988 
    args.write(self._oprot)
989 
    self._oprot.writeMessageEnd()
990 
    self._oprot.trans.flush()
991 
 
992 
  def recv_getTransactionStatus(self, ):
993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
994 
    if mtype == TMessageType.EXCEPTION:
995 
      x = TApplicationException()
996 
      x.read(self._iprot)
997 
      self._iprot.readMessageEnd()
998 
      raise x
999 
    result = getTransactionStatus_result()
1000 
    result.read(self._iprot)
1001 
    self._iprot.readMessageEnd()
3431 rajveer 1002 
    if result.success is not None:
94 ashish 1003 
      return result.success
3431 rajveer 1004 
    if result.ex is not None:
94 ashish 1005 
      raise result.ex
1006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1007 
 
1008 
  def changeTransactionStatus(self, transactionId, status, description):
1009 
    """
1010 
    Parameters:
1011 
     - transactionId
1012 
     - status
1013 
     - description
1014 
    """
1015 
    self.send_changeTransactionStatus(transactionId, status, description)
1016 
    return self.recv_changeTransactionStatus()
1017 
 
1018 
  def send_changeTransactionStatus(self, transactionId, status, description):
1019 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1020 
    args = changeTransactionStatus_args()
1021 
    args.transactionId = transactionId
1022 
    args.status = status
1023 
    args.description = description
1024 
    args.write(self._oprot)
1025 
    self._oprot.writeMessageEnd()
1026 
    self._oprot.trans.flush()
1027 
 
1028 
  def recv_changeTransactionStatus(self, ):
1029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1030 
    if mtype == TMessageType.EXCEPTION:
1031 
      x = TApplicationException()
1032 
      x.read(self._iprot)
1033 
      self._iprot.readMessageEnd()
1034 
      raise x
1035 
    result = changeTransactionStatus_result()
1036 
    result.read(self._iprot)
1037 
    self._iprot.readMessageEnd()
3431 rajveer 1038 
    if result.success is not None:
94 ashish 1039 
      return result.success
3431 rajveer 1040 
    if result.ex is not None:
94 ashish 1041 
      raise result.ex
1042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1043 
 
1398 varun.gupt 1044 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1045 
    """
1046 
    Parameters:
1047 
     - transactionId
1048 
    """
1398 varun.gupt 1049 
    self.send_enqueueTransactionInfoEmail(transactionId)
1050 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1051 
 
1398 varun.gupt 1052 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1053 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1054 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1055 
    args.transactionId = transactionId
1056 
    args.write(self._oprot)
1057 
    self._oprot.writeMessageEnd()
1058 
    self._oprot.trans.flush()
1059 
 
1398 varun.gupt 1060 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1062 
    if mtype == TMessageType.EXCEPTION:
1063 
      x = TApplicationException()
1064 
      x.read(self._iprot)
1065 
      self._iprot.readMessageEnd()
1066 
      raise x
1398 varun.gupt 1067 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1068 
    result.read(self._iprot)
1069 
    self._iprot.readMessageEnd()
3431 rajveer 1070 
    if result.success is not None:
1382 varun.gupt 1071 
      return result.success
3431 rajveer 1072 
    if result.ex is not None:
1382 varun.gupt 1073 
      raise result.ex
1398 varun.gupt 1074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1075 
 
483 rajveer 1076 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1077 
    """
1078 
    Parameters:
483 rajveer 1079 
     - status
1080 
     - from_date
1081 
     - to_date
1082 
     - warehouse_id
94 ashish 1083 
    """
483 rajveer 1084 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1085 
    return self.recv_getAllOrders()
94 ashish 1086 
 
483 rajveer 1087 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1088 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1089 
    args = getAllOrders_args()
1090 
    args.status = status
1091 
    args.from_date = from_date
1092 
    args.to_date = to_date
1093 
    args.warehouse_id = warehouse_id
94 ashish 1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
483 rajveer 1098 
  def recv_getAllOrders(self, ):
94 ashish 1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
483 rajveer 1105 
    result = getAllOrders_result()
94 ashish 1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
3431 rajveer 1108 
    if result.success is not None:
94 ashish 1109 
      return result.success
3431 rajveer 1110 
    if result.ex is not None:
94 ashish 1111 
      raise result.ex
483 rajveer 1112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1113 
 
4133 chandransh 1114 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1115 
    """
1116 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1117 
    Pass the status as null and the limit as 0 to ignore them.
1118 
 
1119 
    Parameters:
1120 
     - statuses
1121 
     - offset
1122 
     - limit
1123 
     - warehouse_id
1124 
    """
1125 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1126 
    return self.recv_getOrdersInBatch()
1127 
 
1128 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1129 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1130 
    args = getOrdersInBatch_args()
1131 
    args.statuses = statuses
1132 
    args.offset = offset
1133 
    args.limit = limit
1134 
    args.warehouse_id = warehouse_id
1135 
    args.write(self._oprot)
1136 
    self._oprot.writeMessageEnd()
1137 
    self._oprot.trans.flush()
1138 
 
1139 
  def recv_getOrdersInBatch(self, ):
1140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1141 
    if mtype == TMessageType.EXCEPTION:
1142 
      x = TApplicationException()
1143 
      x.read(self._iprot)
1144 
      self._iprot.readMessageEnd()
1145 
      raise x
1146 
    result = getOrdersInBatch_result()
1147 
    result.read(self._iprot)
1148 
    self._iprot.readMessageEnd()
1149 
    if result.success is not None:
1150 
      return result.success
1151 
    if result.ex is not None:
1152 
      raise result.ex
1153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1154 
 
1155 
  def getOrderCount(self, statuses, warehouseId):
1156 
    """
1157 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1158 
 
1159 
    Parameters:
1160 
     - statuses
1161 
     - warehouseId
1162 
    """
1163 
    self.send_getOrderCount(statuses, warehouseId)
1164 
    return self.recv_getOrderCount()
1165 
 
1166 
  def send_getOrderCount(self, statuses, warehouseId):
1167 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1168 
    args = getOrderCount_args()
1169 
    args.statuses = statuses
1170 
    args.warehouseId = warehouseId
1171 
    args.write(self._oprot)
1172 
    self._oprot.writeMessageEnd()
1173 
    self._oprot.trans.flush()
1174 
 
1175 
  def recv_getOrderCount(self, ):
1176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1177 
    if mtype == TMessageType.EXCEPTION:
1178 
      x = TApplicationException()
1179 
      x.read(self._iprot)
1180 
      self._iprot.readMessageEnd()
1181 
      raise x
1182 
    result = getOrderCount_result()
1183 
    result.read(self._iprot)
1184 
    self._iprot.readMessageEnd()
1185 
    if result.success is not None:
1186 
      return result.success
1187 
    if result.ex is not None:
1188 
      raise result.ex
1189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1190 
 
999 varun.gupt 1191 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1192 
    """
1132 chandransh 1193 
    Returns orders within a range of their billing dates
3431 rajveer 1194 
 
999 varun.gupt 1195 
    Parameters:
1196 
     - status
1197 
     - start_billing_date
1198 
     - end_billing_date
1199 
     - warehouse_id
1200 
    """
1201 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1202 
    return self.recv_getOrdersByBillingDate()
1203 
 
1204 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1205 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1206 
    args = getOrdersByBillingDate_args()
1207 
    args.status = status
1208 
    args.start_billing_date = start_billing_date
1209 
    args.end_billing_date = end_billing_date
1210 
    args.warehouse_id = warehouse_id
1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
1215 
  def recv_getOrdersByBillingDate(self, ):
1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
1222 
    result = getOrdersByBillingDate_result()
1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
3431 rajveer 1225 
    if result.success is not None:
999 varun.gupt 1226 
      return result.success
3431 rajveer 1227 
    if result.ex is not None:
999 varun.gupt 1228 
      raise result.ex
1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1230 
 
3451 chandransh 1231 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1232 
    """
1233 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1234 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1235 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1236 
 
3427 chandransh 1237 
    Parameters:
1238 
     - fromShippingDate
1239 
     - toShippingDate
1240 
     - providerId
1241 
     - warehouseId
3451 chandransh 1242 
     - cod
3427 chandransh 1243 
    """
3451 chandransh 1244 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1245 
    return self.recv_getOrdersByShippingDate()
1246 
 
3451 chandransh 1247 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1248 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1249 
    args = getOrdersByShippingDate_args()
1250 
    args.fromShippingDate = fromShippingDate
1251 
    args.toShippingDate = toShippingDate
1252 
    args.providerId = providerId
1253 
    args.warehouseId = warehouseId
3451 chandransh 1254 
    args.cod = cod
3427 chandransh 1255 
    args.write(self._oprot)
1256 
    self._oprot.writeMessageEnd()
1257 
    self._oprot.trans.flush()
1258 
 
1259 
  def recv_getOrdersByShippingDate(self, ):
1260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1261 
    if mtype == TMessageType.EXCEPTION:
1262 
      x = TApplicationException()
1263 
      x.read(self._iprot)
1264 
      self._iprot.readMessageEnd()
1265 
      raise x
1266 
    result = getOrdersByShippingDate_result()
1267 
    result.read(self._iprot)
1268 
    self._iprot.readMessageEnd()
3431 rajveer 1269 
    if result.success is not None:
3427 chandransh 1270 
      return result.success
3431 rajveer 1271 
    if result.ex is not None:
3427 chandransh 1272 
      raise result.ex
1273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1274 
 
1382 varun.gupt 1275 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1276 
    """
1277 
    Returns order ids for orders which can be returned
3431 rajveer 1278 
 
1382 varun.gupt 1279 
    Parameters:
1280 
     - customer_id
1281 
     - limit
1282 
    """
1283 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1284 
    return self.recv_getReturnableOrdersForCustomer()
1285 
 
1286 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1287 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1288 
    args = getReturnableOrdersForCustomer_args()
1289 
    args.customer_id = customer_id
1290 
    args.limit = limit
1291 
    args.write(self._oprot)
1292 
    self._oprot.writeMessageEnd()
1293 
    self._oprot.trans.flush()
1294 
 
1295 
  def recv_getReturnableOrdersForCustomer(self, ):
1296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1297 
    if mtype == TMessageType.EXCEPTION:
1298 
      x = TApplicationException()
1299 
      x.read(self._iprot)
1300 
      self._iprot.readMessageEnd()
1301 
      raise x
1302 
    result = getReturnableOrdersForCustomer_result()
1303 
    result.read(self._iprot)
1304 
    self._iprot.readMessageEnd()
3431 rajveer 1305 
    if result.success is not None:
1382 varun.gupt 1306 
      return result.success
3431 rajveer 1307 
    if result.ex is not None:
1382 varun.gupt 1308 
      raise result.ex
1309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1310 
 
1311 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1312 
    """
1313 
    Returns order ids for orders which can be cancelled
3431 rajveer 1314 
 
1382 varun.gupt 1315 
    Parameters:
1316 
     - customer_id
1317 
     - limit
1318 
    """
1319 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1320 
    return self.recv_getCancellableOrdersForCustomer()
1321 
 
1322 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1323 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1324 
    args = getCancellableOrdersForCustomer_args()
1325 
    args.customer_id = customer_id
1326 
    args.limit = limit
1327 
    args.write(self._oprot)
1328 
    self._oprot.writeMessageEnd()
1329 
    self._oprot.trans.flush()
1330 
 
1331 
  def recv_getCancellableOrdersForCustomer(self, ):
1332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1333 
    if mtype == TMessageType.EXCEPTION:
1334 
      x = TApplicationException()
1335 
      x.read(self._iprot)
1336 
      self._iprot.readMessageEnd()
1337 
      raise x
1338 
    result = getCancellableOrdersForCustomer_result()
1339 
    result.read(self._iprot)
1340 
    self._iprot.readMessageEnd()
3431 rajveer 1341 
    if result.success is not None:
1382 varun.gupt 1342 
      return result.success
3431 rajveer 1343 
    if result.ex is not None:
1382 varun.gupt 1344 
      raise result.ex
1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1346 
 
483 rajveer 1347 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1348 
    """
1349 
    Parameters:
483 rajveer 1350 
     - orderId
1351 
     - status
1352 
     - description
94 ashish 1353 
    """
483 rajveer 1354 
    self.send_changeOrderStatus(orderId, status, description)
1355 
    return self.recv_changeOrderStatus()
94 ashish 1356 
 
483 rajveer 1357 
  def send_changeOrderStatus(self, orderId, status, description):
1358 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1359 
    args = changeOrderStatus_args()
1360 
    args.orderId = orderId
1361 
    args.status = status
1362 
    args.description = description
94 ashish 1363 
    args.write(self._oprot)
1364 
    self._oprot.writeMessageEnd()
1365 
    self._oprot.trans.flush()
1366 
 
483 rajveer 1367 
  def recv_changeOrderStatus(self, ):
94 ashish 1368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1369 
    if mtype == TMessageType.EXCEPTION:
1370 
      x = TApplicationException()
1371 
      x.read(self._iprot)
1372 
      self._iprot.readMessageEnd()
1373 
      raise x
483 rajveer 1374 
    result = changeOrderStatus_result()
94 ashish 1375 
    result.read(self._iprot)
1376 
    self._iprot.readMessageEnd()
3431 rajveer 1377 
    if result.success is not None:
94 ashish 1378 
      return result.success
3431 rajveer 1379 
    if result.ex is not None:
94 ashish 1380 
      raise result.ex
483 rajveer 1381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1382 
 
1528 ankur.sing 1383 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1384 
    """
1528 ankur.sing 1385 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1386 
    only user who owns the transaction can view its order details.
3431 rajveer 1387 
 
94 ashish 1388 
    Parameters:
1389 
     - transactionId
1528 ankur.sing 1390 
     - customerId
94 ashish 1391 
    """
1528 ankur.sing 1392 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1393 
    return self.recv_getOrdersForTransaction()
94 ashish 1394 
 
1528 ankur.sing 1395 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1396 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1397 
    args = getOrdersForTransaction_args()
94 ashish 1398 
    args.transactionId = transactionId
1528 ankur.sing 1399 
    args.customerId = customerId
94 ashish 1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
483 rajveer 1404 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
483 rajveer 1411 
    result = getOrdersForTransaction_result()
94 ashish 1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
3431 rajveer 1414 
    if result.success is not None:
94 ashish 1415 
      return result.success
3431 rajveer 1416 
    if result.ex is not None:
94 ashish 1417 
      raise result.ex
483 rajveer 1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1419 
 
3014 chandransh 1420 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1421 
    """
3014 chandransh 1422 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1423 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1424 
 
94 ashish 1425 
    Parameters:
483 rajveer 1426 
     - customerId
1427 
     - from_date
1428 
     - to_date
3014 chandransh 1429 
     - statuses
94 ashish 1430 
    """
3014 chandransh 1431 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1432 
    return self.recv_getOrdersForCustomer()
94 ashish 1433 
 
3014 chandransh 1434 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1435 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1436 
    args = getOrdersForCustomer_args()
1437 
    args.customerId = customerId
1438 
    args.from_date = from_date
1439 
    args.to_date = to_date
3014 chandransh 1440 
    args.statuses = statuses
94 ashish 1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
483 rajveer 1445 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
483 rajveer 1452 
    result = getOrdersForCustomer_result()
94 ashish 1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
3431 rajveer 1455 
    if result.success is not None:
94 ashish 1456 
      return result.success
3431 rajveer 1457 
    if result.ex is not None:
94 ashish 1458 
      raise result.ex
483 rajveer 1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1460 
 
483 rajveer 1461 
  def createOrder(self, order):
94 ashish 1462 
    """
1463 
    Parameters:
483 rajveer 1464 
     - order
94 ashish 1465 
    """
483 rajveer 1466 
    self.send_createOrder(order)
1467 
    return self.recv_createOrder()
94 ashish 1468 
 
483 rajveer 1469 
  def send_createOrder(self, order):
1470 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1471 
    args = createOrder_args()
1472 
    args.order = order
94 ashish 1473 
    args.write(self._oprot)
1474 
    self._oprot.writeMessageEnd()
1475 
    self._oprot.trans.flush()
1476 
 
483 rajveer 1477 
  def recv_createOrder(self, ):
94 ashish 1478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1479 
    if mtype == TMessageType.EXCEPTION:
1480 
      x = TApplicationException()
1481 
      x.read(self._iprot)
1482 
      self._iprot.readMessageEnd()
1483 
      raise x
483 rajveer 1484 
    result = createOrder_result()
94 ashish 1485 
    result.read(self._iprot)
1486 
    self._iprot.readMessageEnd()
3431 rajveer 1487 
    if result.success is not None:
94 ashish 1488 
      return result.success
3431 rajveer 1489 
    if result.ex is not None:
94 ashish 1490 
      raise result.ex
483 rajveer 1491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1492 
 
483 rajveer 1493 
  def getOrder(self, id):
94 ashish 1494 
    """
1495 
    Parameters:
483 rajveer 1496 
     - id
94 ashish 1497 
    """
483 rajveer 1498 
    self.send_getOrder(id)
1499 
    return self.recv_getOrder()
94 ashish 1500 
 
483 rajveer 1501 
  def send_getOrder(self, id):
1502 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1503 
    args = getOrder_args()
1504 
    args.id = id
94 ashish 1505 
    args.write(self._oprot)
1506 
    self._oprot.writeMessageEnd()
1507 
    self._oprot.trans.flush()
1508 
 
483 rajveer 1509 
  def recv_getOrder(self, ):
94 ashish 1510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1511 
    if mtype == TMessageType.EXCEPTION:
1512 
      x = TApplicationException()
1513 
      x.read(self._iprot)
1514 
      self._iprot.readMessageEnd()
1515 
      raise x
483 rajveer 1516 
    result = getOrder_result()
94 ashish 1517 
    result.read(self._iprot)
1518 
    self._iprot.readMessageEnd()
3431 rajveer 1519 
    if result.success is not None:
94 ashish 1520 
      return result.success
3431 rajveer 1521 
    if result.ex is not None:
94 ashish 1522 
      raise result.ex
483 rajveer 1523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1524 
 
483 rajveer 1525 
  def getLineItemsForOrder(self, orderId):
94 ashish 1526 
    """
1527 
    Parameters:
483 rajveer 1528 
     - orderId
94 ashish 1529 
    """
483 rajveer 1530 
    self.send_getLineItemsForOrder(orderId)
1531 
    return self.recv_getLineItemsForOrder()
94 ashish 1532 
 
483 rajveer 1533 
  def send_getLineItemsForOrder(self, orderId):
1534 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1535 
    args = getLineItemsForOrder_args()
1536 
    args.orderId = orderId
94 ashish 1537 
    args.write(self._oprot)
1538 
    self._oprot.writeMessageEnd()
1539 
    self._oprot.trans.flush()
1540 
 
483 rajveer 1541 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1543 
    if mtype == TMessageType.EXCEPTION:
1544 
      x = TApplicationException()
1545 
      x.read(self._iprot)
1546 
      self._iprot.readMessageEnd()
1547 
      raise x
483 rajveer 1548 
    result = getLineItemsForOrder_result()
94 ashish 1549 
    result.read(self._iprot)
1550 
    self._iprot.readMessageEnd()
3431 rajveer 1551 
    if result.success is not None:
94 ashish 1552 
      return result.success
3431 rajveer 1553 
    if result.ex is not None:
94 ashish 1554 
      raise result.ex
483 rajveer 1555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1556 
 
1528 ankur.sing 1557 
  def getOrderForCustomer(self, orderId, customerId):
1558 
    """
1559 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1560 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1561 
 
1528 ankur.sing 1562 
    Parameters:
1563 
     - orderId
1564 
     - customerId
1565 
    """
1566 
    self.send_getOrderForCustomer(orderId, customerId)
1567 
    return self.recv_getOrderForCustomer()
1568 
 
1569 
  def send_getOrderForCustomer(self, orderId, customerId):
1570 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1571 
    args = getOrderForCustomer_args()
1572 
    args.orderId = orderId
1573 
    args.customerId = customerId
1574 
    args.write(self._oprot)
1575 
    self._oprot.writeMessageEnd()
1576 
    self._oprot.trans.flush()
1577 
 
1578 
  def recv_getOrderForCustomer(self, ):
1579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1580 
    if mtype == TMessageType.EXCEPTION:
1581 
      x = TApplicationException()
1582 
      x.read(self._iprot)
1583 
      self._iprot.readMessageEnd()
1584 
      raise x
1585 
    result = getOrderForCustomer_result()
1586 
    result.read(self._iprot)
1587 
    self._iprot.readMessageEnd()
3431 rajveer 1588 
    if result.success is not None:
1528 ankur.sing 1589 
      return result.success
3431 rajveer 1590 
    if result.ex is not None:
1528 ankur.sing 1591 
      raise result.ex
1592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1593 
 
4444 rajveer 1594 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1595 
    """
1596 
    Parameters:
4394 rajveer 1597 
     - type
4444 rajveer 1598 
     - warehouseId
4394 rajveer 1599 
     - status
1600 
     - timestamp
3064 chandransh 1601 
    """
4444 rajveer 1602 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1603 
    return self.recv_getAlerts()
1604 
 
4444 rajveer 1605 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1606 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1607 
    args = getAlerts_args()
4394 rajveer 1608 
    args.type = type
4444 rajveer 1609 
    args.warehouseId = warehouseId
4394 rajveer 1610 
    args.status = status
1611 
    args.timestamp = timestamp
3064 chandransh 1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
1616 
  def recv_getAlerts(self, ):
1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
1623 
    result = getAlerts_result()
1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
3431 rajveer 1626 
    if result.success is not None:
3064 chandransh 1627 
      return result.success
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1629 
 
4444 rajveer 1630 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1631 
    """
1632 
    Parameters:
1633 
     - type
4444 rajveer 1634 
     - warehouseId
4394 rajveer 1635 
     - description
3064 chandransh 1636 
    """
4444 rajveer 1637 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1638 
    self.recv_addAlert()
3064 chandransh 1639 
 
4444 rajveer 1640 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1641 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1642 
    args = addAlert_args()
3064 chandransh 1643 
    args.type = type
4444 rajveer 1644 
    args.warehouseId = warehouseId
4394 rajveer 1645 
    args.description = description
3064 chandransh 1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
4394 rajveer 1650 
  def recv_addAlert(self, ):
3064 chandransh 1651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1652 
    if mtype == TMessageType.EXCEPTION:
1653 
      x = TApplicationException()
1654 
      x.read(self._iprot)
1655 
      self._iprot.readMessageEnd()
1656 
      raise x
4394 rajveer 1657 
    result = addAlert_result()
3064 chandransh 1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
1660 
    return
1661 
 
4444 rajveer 1662 
  def markAlertsAsSeen(self, warehouseId):
1663 
    """
1664 
    Parameters:
1665 
     - warehouseId
1666 
    """
1667 
    self.send_markAlertsAsSeen(warehouseId)
1668 
    self.recv_markAlertsAsSeen()
1669 
 
1670 
  def send_markAlertsAsSeen(self, warehouseId):
1671 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1672 
    args = markAlertsAsSeen_args()
1673 
    args.warehouseId = warehouseId
1674 
    args.write(self._oprot)
1675 
    self._oprot.writeMessageEnd()
1676 
    self._oprot.trans.flush()
1677 
 
1678 
  def recv_markAlertsAsSeen(self, ):
1679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1680 
    if mtype == TMessageType.EXCEPTION:
1681 
      x = TApplicationException()
1682 
      x.read(self._iprot)
1683 
      self._iprot.readMessageEnd()
1684 
      raise x
1685 
    result = markAlertsAsSeen_result()
1686 
    result.read(self._iprot)
1687 
    self._iprot.readMessageEnd()
1688 
    return
1689 
 
3064 chandransh 1690 
  def getValidOrderCount(self, ):
1691 
    """
1692 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1693 
    """
1694 
    self.send_getValidOrderCount()
1695 
    return self.recv_getValidOrderCount()
1696 
 
1697 
  def send_getValidOrderCount(self, ):
1698 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1699 
    args = getValidOrderCount_args()
1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_getValidOrderCount(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = getValidOrderCount_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
3431 rajveer 1714 
    if result.success is not None:
3064 chandransh 1715 
      return result.success
1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1717 
 
1718 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1719 
    """
1720 
    Returns the number of distinct customers who have done successful transactions
1721 
    """
1722 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1723 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1724 
 
1725 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1726 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1727 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
3431 rajveer 1742 
    if result.success is not None:
3064 chandransh 1743 
      return result.success
1744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1745 
 
1746 
  def getValidOrdersAmountRange(self, ):
1747 
    """
1748 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1749 
    List contains two values, first minimum amount and second maximum amount.
1750 
    """
1751 
    self.send_getValidOrdersAmountRange()
1752 
    return self.recv_getValidOrdersAmountRange()
1753 
 
1754 
  def send_getValidOrdersAmountRange(self, ):
1755 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1756 
    args = getValidOrdersAmountRange_args()
1757 
    args.write(self._oprot)
1758 
    self._oprot.writeMessageEnd()
1759 
    self._oprot.trans.flush()
1760 
 
1761 
  def recv_getValidOrdersAmountRange(self, ):
1762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1763 
    if mtype == TMessageType.EXCEPTION:
1764 
      x = TApplicationException()
1765 
      x.read(self._iprot)
1766 
      self._iprot.readMessageEnd()
1767 
      raise x
1768 
    result = getValidOrdersAmountRange_result()
1769 
    result.read(self._iprot)
1770 
    self._iprot.readMessageEnd()
3431 rajveer 1771 
    if result.success is not None:
3064 chandransh 1772 
      return result.success
1773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1774 
 
1775 
  def getValidOrders(self, limit):
1776 
    """
1777 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1778 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1779 
 
3064 chandransh 1780 
    Parameters:
1781 
     - limit
1782 
    """
1783 
    self.send_getValidOrders(limit)
1784 
    return self.recv_getValidOrders()
1785 
 
1786 
  def send_getValidOrders(self, limit):
1787 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1788 
    args = getValidOrders_args()
1789 
    args.limit = limit
1790 
    args.write(self._oprot)
1791 
    self._oprot.writeMessageEnd()
1792 
    self._oprot.trans.flush()
1793 
 
1794 
  def recv_getValidOrders(self, ):
1795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1796 
    if mtype == TMessageType.EXCEPTION:
1797 
      x = TApplicationException()
1798 
      x.read(self._iprot)
1799 
      self._iprot.readMessageEnd()
1800 
      raise x
1801 
    result = getValidOrders_result()
1802 
    result.read(self._iprot)
1803 
    self._iprot.readMessageEnd()
3431 rajveer 1804 
    if result.success is not None:
3064 chandransh 1805 
      return result.success
1806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1807 
 
1220 chandransh 1808 
  def batchOrders(self, warehouseId):
1809 
    """
1810 
    Create a batch of all the pending orders for the given warehouse.
1811 
    The returned list is orderd by created_timestamp.
1812 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1813 
 
1220 chandransh 1814 
    Parameters:
1815 
     - warehouseId
1816 
    """
1817 
    self.send_batchOrders(warehouseId)
1818 
    return self.recv_batchOrders()
1819 
 
1820 
  def send_batchOrders(self, warehouseId):
1821 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1822 
    args = batchOrders_args()
1823 
    args.warehouseId = warehouseId
1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
1828 
  def recv_batchOrders(self, ):
1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
1835 
    result = batchOrders_result()
1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
3431 rajveer 1838 
    if result.success is not None:
1220 chandransh 1839 
      return result.success
3431 rajveer 1840 
    if result.ex is not None:
1220 chandransh 1841 
      raise result.ex
1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1843 
 
1208 chandransh 1844 
  def markOrderAsOutOfStock(self, orderId):
1845 
    """
1846 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1847 
 
1208 chandransh 1848 
    Parameters:
1849 
     - orderId
1850 
    """
1851 
    self.send_markOrderAsOutOfStock(orderId)
1852 
    return self.recv_markOrderAsOutOfStock()
1853 
 
1854 
  def send_markOrderAsOutOfStock(self, orderId):
1855 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1856 
    args = markOrderAsOutOfStock_args()
1857 
    args.orderId = orderId
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_markOrderAsOutOfStock(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = markOrderAsOutOfStock_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
3431 rajveer 1872 
    if result.success is not None:
1208 chandransh 1873 
      return result.success
3431 rajveer 1874 
    if result.ex is not None:
1208 chandransh 1875 
      raise result.ex
1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1877 
 
3064 chandransh 1878 
  def verifyOrder(self, orderId):
759 chandransh 1879 
    """
3064 chandransh 1880 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1881 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1882 
    used for all other orders as well.
1883 
    Throws an exception if no such order exists.
3431 rajveer 1884 
 
759 chandransh 1885 
    Parameters:
3064 chandransh 1886 
     - orderId
759 chandransh 1887 
    """
3064 chandransh 1888 
    self.send_verifyOrder(orderId)
1889 
    return self.recv_verifyOrder()
759 chandransh 1890 
 
3064 chandransh 1891 
  def send_verifyOrder(self, orderId):
1892 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1893 
    args = verifyOrder_args()
1894 
    args.orderId = orderId
759 chandransh 1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
3064 chandransh 1899 
  def recv_verifyOrder(self, ):
759 chandransh 1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
3064 chandransh 1906 
    result = verifyOrder_result()
759 chandransh 1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
3431 rajveer 1909 
    if result.success is not None:
759 chandransh 1910 
      return result.success
3431 rajveer 1911 
    if result.ex is not None:
759 chandransh 1912 
      raise result.ex
3064 chandransh 1913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1914 
 
3064 chandransh 1915 
  def acceptOrder(self, orderId):
1113 chandransh 1916 
    """
3064 chandransh 1917 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1918 
    given order is not a COD order, it also captures the payment if the same has
1919 
    not been captured.
1920 
    Throws an exception if no such order exists.
3431 rajveer 1921 
 
1113 chandransh 1922 
    Parameters:
3064 chandransh 1923 
     - orderId
1113 chandransh 1924 
    """
3064 chandransh 1925 
    self.send_acceptOrder(orderId)
1926 
    return self.recv_acceptOrder()
1113 chandransh 1927 
 
3064 chandransh 1928 
  def send_acceptOrder(self, orderId):
1929 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1930 
    args = acceptOrder_args()
1931 
    args.orderId = orderId
1113 chandransh 1932 
    args.write(self._oprot)
1933 
    self._oprot.writeMessageEnd()
1934 
    self._oprot.trans.flush()
1935 
 
3064 chandransh 1936 
  def recv_acceptOrder(self, ):
1113 chandransh 1937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1938 
    if mtype == TMessageType.EXCEPTION:
1939 
      x = TApplicationException()
1940 
      x.read(self._iprot)
1941 
      self._iprot.readMessageEnd()
1942 
      raise x
3064 chandransh 1943 
    result = acceptOrder_result()
1113 chandransh 1944 
    result.read(self._iprot)
1945 
    self._iprot.readMessageEnd()
3431 rajveer 1946 
    if result.success is not None:
1113 chandransh 1947 
      return result.success
3431 rajveer 1948 
    if result.ex is not None:
1113 chandransh 1949 
      raise result.ex
3064 chandransh 1950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1951 
 
4283 anupam.sin 1952 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1953 
    """
3064 chandransh 1954 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1955 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1956 
    the IMEI no. if a -1 is supplied.
1957 
    Also, it generates an invoice number for the order, marks the order as
1958 
    BILLED and sets the billing timestamp.
1959 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1960 
 
1135 chandransh 1961 
    Parameters:
3064 chandransh 1962 
     - orderId
1963 
     - invoice_number
4283 anupam.sin 1964 
     - imeiNumber
1965 
     - itemNumber
3064 chandransh 1966 
     - billed_by
4264 rajveer 1967 
     - jacketNumber
4283 anupam.sin 1968 
     - billingType
1969 
     - vendorId
1135 chandransh 1970 
    """
4283 anupam.sin 1971 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1972 
    return self.recv_addBillingDetails()
1135 chandransh 1973 
 
4283 anupam.sin 1974 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1975 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1976 
    args = addBillingDetails_args()
1977 
    args.orderId = orderId
1978 
    args.invoice_number = invoice_number
4283 anupam.sin 1979 
    args.imeiNumber = imeiNumber
1980 
    args.itemNumber = itemNumber
3064 chandransh 1981 
    args.billed_by = billed_by
4264 rajveer 1982 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1983 
    args.billingType = billingType
1984 
    args.vendorId = vendorId
1135 chandransh 1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
3064 chandransh 1989 
  def recv_addBillingDetails(self, ):
1135 chandransh 1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
3064 chandransh 1996 
    result = addBillingDetails_result()
1135 chandransh 1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
3431 rajveer 1999 
    if result.success is not None:
3064 chandransh 2000 
      return result.success
3431 rajveer 2001 
    if result.ex is not None:
1135 chandransh 2002 
      raise result.ex
3064 chandransh 2003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2004 
 
3064 chandransh 2005 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2006 
    """
3064 chandransh 2007 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2008 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2009 
 
1408 ankur.sing 2010 
    Parameters:
3064 chandransh 2011 
     - warehouseId
1408 ankur.sing 2012 
     - providerId
3064 chandransh 2013 
     - cod
1408 ankur.sing 2014 
    """
3064 chandransh 2015 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2016 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2017 
 
3064 chandransh 2018 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2019 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2020 
    args = markOrdersAsManifested_args()
2021 
    args.warehouseId = warehouseId
1408 ankur.sing 2022 
    args.providerId = providerId
3064 chandransh 2023 
    args.cod = cod
1408 ankur.sing 2024 
    args.write(self._oprot)
2025 
    self._oprot.writeMessageEnd()
2026 
    self._oprot.trans.flush()
2027 
 
3064 chandransh 2028 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2030 
    if mtype == TMessageType.EXCEPTION:
2031 
      x = TApplicationException()
2032 
      x.read(self._iprot)
2033 
      self._iprot.readMessageEnd()
2034 
      raise x
3064 chandransh 2035 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2036 
    result.read(self._iprot)
2037 
    self._iprot.readMessageEnd()
3431 rajveer 2038 
    if result.success is not None:
1408 ankur.sing 2039 
      return result.success
3431 rajveer 2040 
    if result.ex is not None:
3064 chandransh 2041 
      raise result.ex
2042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2043 
 
4410 rajveer 2044 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2045 
    """
2046 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2047 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2048 
 
2049 
    Parameters:
2050 
     - warehouseId
2051 
     - providerId
2052 
     - cod
2053 
    """
2054 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2055 
    return self.recv_markOrdersAsShippedFromWarehouse()
2056 
 
2057 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2058 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2059 
    args = markOrdersAsShippedFromWarehouse_args()
2060 
    args.warehouseId = warehouseId
2061 
    args.providerId = providerId
2062 
    args.cod = cod
2063 
    args.write(self._oprot)
2064 
    self._oprot.writeMessageEnd()
2065 
    self._oprot.trans.flush()
2066 
 
2067 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2069 
    if mtype == TMessageType.EXCEPTION:
2070 
      x = TApplicationException()
2071 
      x.read(self._iprot)
2072 
      self._iprot.readMessageEnd()
2073 
      raise x
2074 
    result = markOrdersAsShippedFromWarehouse_result()
2075 
    result.read(self._iprot)
2076 
    self._iprot.readMessageEnd()
2077 
    if result.success is not None:
2078 
      return result.success
2079 
    if result.ex is not None:
2080 
      raise result.ex
2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2082 
 
3064 chandransh 2083 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2084 
    """
3064 chandransh 2085 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2086 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2087 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2088 
 
94 ashish 2089 
    Parameters:
3064 chandransh 2090 
     - providerId
2091 
     - pickupDetails
304 ashish 2092 
    """
3064 chandransh 2093 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2094 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2095 
 
3064 chandransh 2096 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2097 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2098 
    args = markOrdersAsPickedUp_args()
2099 
    args.providerId = providerId
2100 
    args.pickupDetails = pickupDetails
304 ashish 2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
3064 chandransh 2105 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
3064 chandransh 2112 
    result = markOrdersAsPickedUp_result()
304 ashish 2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
3431 rajveer 2115 
    if result.success is not None:
304 ashish 2116 
      return result.success
3431 rajveer 2117 
    if result.ex is not None:
3064 chandransh 2118 
      raise result.ex
2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2120 
 
3064 chandransh 2121 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2122 
    """
3064 chandransh 2123 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2124 
    the name of the receiver.
2125 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2126 
 
304 ashish 2127 
    Parameters:
3064 chandransh 2128 
     - providerId
2129 
     - deliveredOrders
304 ashish 2130 
    """
3064 chandransh 2131 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2132 
    self.recv_markOrdersAsDelivered()
304 ashish 2133 
 
3064 chandransh 2134 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2135 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2136 
    args = markOrdersAsDelivered_args()
2137 
    args.providerId = providerId
2138 
    args.deliveredOrders = deliveredOrders
304 ashish 2139 
    args.write(self._oprot)
2140 
    self._oprot.writeMessageEnd()
2141 
    self._oprot.trans.flush()
2142 
 
3064 chandransh 2143 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2145 
    if mtype == TMessageType.EXCEPTION:
2146 
      x = TApplicationException()
2147 
      x.read(self._iprot)
2148 
      self._iprot.readMessageEnd()
2149 
      raise x
3064 chandransh 2150 
    result = markOrdersAsDelivered_result()
304 ashish 2151 
    result.read(self._iprot)
2152 
    self._iprot.readMessageEnd()
3431 rajveer 2153 
    if result.ex is not None:
3064 chandransh 2154 
      raise result.ex
304 ashish 2155 
    return
2156 
 
3064 chandransh 2157 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2158 
    """
3064 chandransh 2159 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2160 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2161 
 
3064 chandransh 2162 
    Parameters:
2163 
     - providerId
2164 
     - returnedOrders
1596 ankur.sing 2165 
    """
3064 chandransh 2166 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2167 
    self.recv_markOrdersAsFailed()
304 ashish 2168 
 
3064 chandransh 2169 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2170 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2171 
    args = markOrdersAsFailed_args()
2172 
    args.providerId = providerId
2173 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2174 
    args.write(self._oprot)
2175 
    self._oprot.writeMessageEnd()
2176 
    self._oprot.trans.flush()
2177 
 
3064 chandransh 2178 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2180 
    if mtype == TMessageType.EXCEPTION:
2181 
      x = TApplicationException()
2182 
      x.read(self._iprot)
2183 
      self._iprot.readMessageEnd()
2184 
      raise x
3064 chandransh 2185 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2186 
    result.read(self._iprot)
2187 
    self._iprot.readMessageEnd()
3431 rajveer 2188 
    if result.ex is not None:
3064 chandransh 2189 
      raise result.ex
2190 
    return
1596 ankur.sing 2191 
 
3064 chandransh 2192 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2193 
    """
3064 chandransh 2194 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2195 
 
3064 chandransh 2196 
    Parameters:
2197 
     - providerId
2198 
     - undeliveredOrders
1627 ankur.sing 2199 
    """
3064 chandransh 2200 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2201 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2202 
 
3064 chandransh 2203 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2204 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2205 
    args = updateNonDeliveryReason_args()
2206 
    args.providerId = providerId
2207 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
3064 chandransh 2212 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
3064 chandransh 2219 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
3431 rajveer 2222 
    if result.ex is not None:
3064 chandransh 2223 
      raise result.ex
2224 
    return
1627 ankur.sing 2225 
 
3064 chandransh 2226 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2227 
    """
3064 chandransh 2228 
    Returns the list of orders whose delivery time has passed but have not been
2229 
    delivered yet for the given provider and warehouse. To get a complete list of
2230 
    undelivered orders, pass them as -1.
2231 
    Returns an empty list if no such orders exist.
3431 rajveer 2232 
 
1886 ankur.sing 2233 
    Parameters:
3064 chandransh 2234 
     - providerId
2235 
     - warehouseId
1886 ankur.sing 2236 
    """
3064 chandransh 2237 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2238 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2239 
 
3064 chandransh 2240 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2241 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2242 
    args = getUndeliveredOrders_args()
2243 
    args.providerId = providerId
2244 
    args.warehouseId = warehouseId
1886 ankur.sing 2245 
    args.write(self._oprot)
2246 
    self._oprot.writeMessageEnd()
2247 
    self._oprot.trans.flush()
2248 
 
3064 chandransh 2249 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2251 
    if mtype == TMessageType.EXCEPTION:
2252 
      x = TApplicationException()
2253 
      x.read(self._iprot)
2254 
      self._iprot.readMessageEnd()
2255 
      raise x
3064 chandransh 2256 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2257 
    result.read(self._iprot)
2258 
    self._iprot.readMessageEnd()
3431 rajveer 2259 
    if result.success is not None:
1886 ankur.sing 2260 
      return result.success
3064 chandransh 2261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2262 
 
2536 chandransh 2263 
  def toggleDOAFlag(self, orderId):
2264 
    """
2265 
    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.
2266 
    Returns the final flag status.
2267 
    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 2268 
 
2536 chandransh 2269 
    Parameters:
2270 
     - orderId
2271 
    """
2272 
    self.send_toggleDOAFlag(orderId)
2273 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2274 
 
2536 chandransh 2275 
  def send_toggleDOAFlag(self, orderId):
2276 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2277 
    args = toggleDOAFlag_args()
2278 
    args.orderId = orderId
2279 
    args.write(self._oprot)
2280 
    self._oprot.writeMessageEnd()
2281 
    self._oprot.trans.flush()
2282 
 
2283 
  def recv_toggleDOAFlag(self, ):
2284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2285 
    if mtype == TMessageType.EXCEPTION:
2286 
      x = TApplicationException()
2287 
      x.read(self._iprot)
2288 
      self._iprot.readMessageEnd()
2289 
      raise x
2290 
    result = toggleDOAFlag_result()
2291 
    result.read(self._iprot)
2292 
    self._iprot.readMessageEnd()
3431 rajveer 2293 
    if result.success is not None:
2536 chandransh 2294 
      return result.success
3431 rajveer 2295 
    if result.ex is not None:
2536 chandransh 2296 
      raise result.ex
2297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2298 
 
4454 rajveer 2299 
  def markOrderDoaRequestReceived(self, orderId):
2300 
    """
2301 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2302 
 
2303 
    Parameters:
2304 
     - orderId
2305 
    """
2306 
    self.send_markOrderDoaRequestReceived(orderId)
2307 
    return self.recv_markOrderDoaRequestReceived()
2308 
 
2309 
  def send_markOrderDoaRequestReceived(self, orderId):
2310 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2311 
    args = markOrderDoaRequestReceived_args()
2312 
    args.orderId = orderId
2313 
    args.write(self._oprot)
2314 
    self._oprot.writeMessageEnd()
2315 
    self._oprot.trans.flush()
2316 
 
2317 
  def recv_markOrderDoaRequestReceived(self, ):
2318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2319 
    if mtype == TMessageType.EXCEPTION:
2320 
      x = TApplicationException()
2321 
      x.read(self._iprot)
2322 
      self._iprot.readMessageEnd()
2323 
      raise x
2324 
    result = markOrderDoaRequestReceived_result()
2325 
    result.read(self._iprot)
2326 
    self._iprot.readMessageEnd()
2327 
    if result.success is not None:
2328 
      return result.success
2329 
    if result.ex is not None:
2330 
      raise result.ex
2331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2332 
 
2333 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2334 
    """
2335 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2336 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2337 
 
2338 
    Parameters:
2339 
     - orderId
2340 
     - isAuthorized
2341 
    """
2342 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2343 
    return self.recv_markOrderDoaRequestAuthorized()
2344 
 
2345 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2346 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2347 
    args = markOrderDoaRequestAuthorized_args()
2348 
    args.orderId = orderId
2349 
    args.isAuthorized = isAuthorized
2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
2354 
  def recv_markOrderDoaRequestAuthorized(self, ):
2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
2361 
    result = markOrderDoaRequestAuthorized_result()
2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
2364 
    if result.success is not None:
2365 
      return result.success
2366 
    if result.ex is not None:
2367 
      raise result.ex
2368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2369 
 
2536 chandransh 2370 
  def requestPickupNumber(self, orderId):
2371 
    """
2372 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2373 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2374 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2375 
    For any other status, it returns false.
2376 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2377 
 
2536 chandransh 2378 
    Parameters:
2379 
     - orderId
2380 
    """
2381 
    self.send_requestPickupNumber(orderId)
2382 
    return self.recv_requestPickupNumber()
2383 
 
2384 
  def send_requestPickupNumber(self, orderId):
2385 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2386 
    args = requestPickupNumber_args()
2387 
    args.orderId = orderId
2388 
    args.write(self._oprot)
2389 
    self._oprot.writeMessageEnd()
2390 
    self._oprot.trans.flush()
2391 
 
2392 
  def recv_requestPickupNumber(self, ):
2393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2394 
    if mtype == TMessageType.EXCEPTION:
2395 
      x = TApplicationException()
2396 
      x.read(self._iprot)
2397 
      self._iprot.readMessageEnd()
2398 
      raise x
2399 
    result = requestPickupNumber_result()
2400 
    result.read(self._iprot)
2401 
    self._iprot.readMessageEnd()
3431 rajveer 2402 
    if result.success is not None:
2536 chandransh 2403 
      return result.success
3431 rajveer 2404 
    if result.ex is not None:
2536 chandransh 2405 
      raise result.ex
2406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2407 
 
2408 
  def authorizePickup(self, orderId, pickupNumber):
2409 
    """
4452 rajveer 2410 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2411 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2412 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2413 
    	3. Returns true
2591 chandransh 2414 
    If the order is in any other status, it returns false.
2536 chandransh 2415 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2416 
 
2536 chandransh 2417 
    Parameters:
2418 
     - orderId
2419 
     - pickupNumber
2420 
    """
2421 
    self.send_authorizePickup(orderId, pickupNumber)
2422 
    return self.recv_authorizePickup()
2423 
 
2424 
  def send_authorizePickup(self, orderId, pickupNumber):
2425 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2426 
    args = authorizePickup_args()
2427 
    args.orderId = orderId
2428 
    args.pickupNumber = pickupNumber
2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
2433 
  def recv_authorizePickup(self, ):
2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
2440 
    result = authorizePickup_result()
2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
3431 rajveer 2443 
    if result.success is not None:
2536 chandransh 2444 
      return result.success
3431 rajveer 2445 
    if result.ex is not None:
2536 chandransh 2446 
      raise result.ex
2447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2448 
 
2764 chandransh 2449 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2450 
    """
2451 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2452 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2453 
 
2764 chandransh 2454 
    Parameters:
2455 
     - providerId
2456 
     - pickupDetails
2457 
    """
2458 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2459 
    return self.recv_markDoasAsPickedUp()
2460 
 
2461 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2462 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2463 
    args = markDoasAsPickedUp_args()
2464 
    args.providerId = providerId
2465 
    args.pickupDetails = pickupDetails
2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
2470 
  def recv_markDoasAsPickedUp(self, ):
2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
2477 
    result = markDoasAsPickedUp_result()
2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
3431 rajveer 2480 
    if result.success is not None:
2764 chandransh 2481 
      return result.success
2482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2483 
 
4479 rajveer 2484 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2485 
    """
4452 rajveer 2486 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
2616 chandransh 2487 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2488 
    If the order is in any other state, it returns false.
2489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2490 
 
2591 chandransh 2491 
    Parameters:
2492 
     - orderId
4479 rajveer 2493 
     - receiveCondition
2591 chandransh 2494 
    """
4479 rajveer 2495 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2496 
    return self.recv_receiveReturn()
2536 chandransh 2497 
 
4479 rajveer 2498 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2499 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2500 
    args = receiveReturn_args()
2591 chandransh 2501 
    args.orderId = orderId
4479 rajveer 2502 
    args.receiveCondition = receiveCondition
2591 chandransh 2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2616 chandransh 2507 
  def recv_receiveReturn(self, ):
2591 chandransh 2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2616 chandransh 2514 
    result = receiveReturn_result()
2591 chandransh 2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
3431 rajveer 2517 
    if result.success is not None:
2591 chandransh 2518 
      return result.success
3431 rajveer 2519 
    if result.ex is not None:
2591 chandransh 2520 
      raise result.ex
2616 chandransh 2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2522 
 
2523 
  def validateDoa(self, orderId, isValid):
2524 
    """
4452 rajveer 2525 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2526 
    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 2527 
    If the order is in any other state, it returns false.
2528 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2529 
 
2591 chandransh 2530 
    Parameters:
2531 
     - orderId
2532 
     - isValid
2533 
    """
2534 
    self.send_validateDoa(orderId, isValid)
2535 
    return self.recv_validateDoa()
2536 
 
2537 
  def send_validateDoa(self, orderId, isValid):
2538 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2539 
    args = validateDoa_args()
2540 
    args.orderId = orderId
2541 
    args.isValid = isValid
2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
2546 
  def recv_validateDoa(self, ):
2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
2553 
    result = validateDoa_result()
2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
3431 rajveer 2556 
    if result.success is not None:
2591 chandransh 2557 
      return result.success
3431 rajveer 2558 
    if result.ex is not None:
2591 chandransh 2559 
      raise result.ex
2560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2561 
 
2616 chandransh 2562 
  def reshipOrder(self, orderId):
2563 
    """
2564 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2565 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2566 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2567 
 
2568 
    If the order is in DOA_CERT_VALID state, it does the following:
2569 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2570 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2571 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2572 
 
2616 chandransh 2573 
    Returns the id of the newly created order.
3431 rajveer 2574 
 
2616 chandransh 2575 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2576 
 
2616 chandransh 2577 
    Parameters:
2578 
     - orderId
2579 
    """
2580 
    self.send_reshipOrder(orderId)
2581 
    return self.recv_reshipOrder()
2591 chandransh 2582 
 
2616 chandransh 2583 
  def send_reshipOrder(self, orderId):
2584 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2585 
    args = reshipOrder_args()
2586 
    args.orderId = orderId
2587 
    args.write(self._oprot)
2588 
    self._oprot.writeMessageEnd()
2589 
    self._oprot.trans.flush()
2590 
 
2591 
  def recv_reshipOrder(self, ):
2592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2593 
    if mtype == TMessageType.EXCEPTION:
2594 
      x = TApplicationException()
2595 
      x.read(self._iprot)
2596 
      self._iprot.readMessageEnd()
2597 
      raise x
2598 
    result = reshipOrder_result()
2599 
    result.read(self._iprot)
2600 
    self._iprot.readMessageEnd()
3431 rajveer 2601 
    if result.success is not None:
2616 chandransh 2602 
      return result.success
3431 rajveer 2603 
    if result.ex is not None:
2616 chandransh 2604 
      raise result.ex
2605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2606 
 
3226 chandransh 2607 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2608 
    """
2609 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2610 
    	1. Creates a refund request for batch processing.
2611 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2612 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2613 
 
2616 chandransh 2614 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2615 
    	1. Creates a refund request for batch processing.
3226 chandransh 2616 
    	2. Cancels the reservation of the item in the warehouse.
2617 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2618 
 
3226 chandransh 2619 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2620 
    	1. Cancels the reservation of the item in the warehouse.
2621 
    	2. Marks the current order as CANCELED.
2622 
 
2623 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2624 
 
2616 chandransh 2625 
    Returns True if it is successful, False otherwise.
3431 rajveer 2626 
 
2616 chandransh 2627 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2628 
 
2616 chandransh 2629 
    Parameters:
2630 
     - orderId
3226 chandransh 2631 
     - refundedBy
2632 
     - reason
2616 chandransh 2633 
    """
3226 chandransh 2634 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2635 
    return self.recv_refundOrder()
2636 
 
3226 chandransh 2637 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2638 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2639 
    args = refundOrder_args()
2640 
    args.orderId = orderId
3226 chandransh 2641 
    args.refundedBy = refundedBy
2642 
    args.reason = reason
2616 chandransh 2643 
    args.write(self._oprot)
2644 
    self._oprot.writeMessageEnd()
2645 
    self._oprot.trans.flush()
2646 
 
2647 
  def recv_refundOrder(self, ):
2648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2649 
    if mtype == TMessageType.EXCEPTION:
2650 
      x = TApplicationException()
2651 
      x.read(self._iprot)
2652 
      self._iprot.readMessageEnd()
2653 
      raise x
2654 
    result = refundOrder_result()
2655 
    result.read(self._iprot)
2656 
    self._iprot.readMessageEnd()
3431 rajveer 2657 
    if result.success is not None:
2616 chandransh 2658 
      return result.success
3431 rajveer 2659 
    if result.ex is not None:
2616 chandransh 2660 
      raise result.ex
2661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2662 
 
2690 chandransh 2663 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2664 
    """
2665 
    Get all return orders created between the from and to dates for the given warehouse.
2666 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2667 
 
2690 chandransh 2668 
    Parameters:
2669 
     - warehouseId
2670 
     - fromDate
2671 
     - toDate
2672 
    """
2673 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2674 
    return self.recv_getReturnOrders()
2616 chandransh 2675 
 
2690 chandransh 2676 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2677 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2678 
    args = getReturnOrders_args()
2679 
    args.warehouseId = warehouseId
2680 
    args.fromDate = fromDate
2681 
    args.toDate = toDate
2682 
    args.write(self._oprot)
2683 
    self._oprot.writeMessageEnd()
2684 
    self._oprot.trans.flush()
2685 
 
2686 
  def recv_getReturnOrders(self, ):
2687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2688 
    if mtype == TMessageType.EXCEPTION:
2689 
      x = TApplicationException()
2690 
      x.read(self._iprot)
2691 
      self._iprot.readMessageEnd()
2692 
      raise x
2693 
    result = getReturnOrders_result()
2694 
    result.read(self._iprot)
2695 
    self._iprot.readMessageEnd()
3431 rajveer 2696 
    if result.success is not None:
2690 chandransh 2697 
      return result.success
2698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2699 
 
2700 chandransh 2700 
  def getReturnOrder(self, id):
2701 
    """
2702 
    Returns the ReturnOrder corresponding to the given id.
2703 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2704 
 
2700 chandransh 2705 
    Parameters:
2706 
     - id
2707 
    """
2708 
    self.send_getReturnOrder(id)
2709 
    return self.recv_getReturnOrder()
2710 
 
2711 
  def send_getReturnOrder(self, id):
2712 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2713 
    args = getReturnOrder_args()
2714 
    args.id = id
2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
2719 
  def recv_getReturnOrder(self, ):
2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
2726 
    result = getReturnOrder_result()
2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
3431 rajveer 2729 
    if result.success is not None:
2700 chandransh 2730 
      return result.success
3431 rajveer 2731 
    if result.ex is not None:
2700 chandransh 2732 
      raise result.ex
2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2734 
 
2690 chandransh 2735 
  def processReturn(self, returnOrderId):
2736 
    """
2737 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2738 
 
2690 chandransh 2739 
    Parameters:
2740 
     - returnOrderId
2741 
    """
2742 
    self.send_processReturn(returnOrderId)
2743 
    self.recv_processReturn()
2744 
 
2745 
  def send_processReturn(self, returnOrderId):
2746 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2747 
    args = processReturn_args()
2748 
    args.returnOrderId = returnOrderId
2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_processReturn(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = processReturn_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
3431 rajveer 2763 
    if result.ex is not None:
2690 chandransh 2764 
      raise result.ex
2765 
    return
2766 
 
2819 chandransh 2767 
  def createPurchaseOrder(self, warehouseId):
2768 
    """
2769 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2770 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2771 
 
2819 chandransh 2772 
    Parameters:
2773 
     - warehouseId
2774 
    """
2775 
    self.send_createPurchaseOrder(warehouseId)
2776 
    return self.recv_createPurchaseOrder()
2690 chandransh 2777 
 
2819 chandransh 2778 
  def send_createPurchaseOrder(self, warehouseId):
2779 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2780 
    args = createPurchaseOrder_args()
2781 
    args.warehouseId = warehouseId
2782 
    args.write(self._oprot)
2783 
    self._oprot.writeMessageEnd()
2784 
    self._oprot.trans.flush()
2785 
 
2786 
  def recv_createPurchaseOrder(self, ):
2787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2788 
    if mtype == TMessageType.EXCEPTION:
2789 
      x = TApplicationException()
2790 
      x.read(self._iprot)
2791 
      self._iprot.readMessageEnd()
2792 
      raise x
2793 
    result = createPurchaseOrder_result()
2794 
    result.read(self._iprot)
2795 
    self._iprot.readMessageEnd()
3431 rajveer 2796 
    if result.success is not None:
2819 chandransh 2797 
      return result.success
3431 rajveer 2798 
    if result.ex is not None:
2819 chandransh 2799 
      raise result.ex
2800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2801 
 
3451 chandransh 2802 
  def updateWeight(self, orderId, weight):
2803 
    """
2804 
    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 2805 
 
3451 chandransh 2806 
    Parameters:
2807 
     - orderId
2808 
     - weight
2809 
    """
2810 
    self.send_updateWeight(orderId, weight)
2811 
    return self.recv_updateWeight()
2812 
 
2813 
  def send_updateWeight(self, orderId, weight):
2814 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2815 
    args = updateWeight_args()
2816 
    args.orderId = orderId
2817 
    args.weight = weight
2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2822 
  def recv_updateWeight(self, ):
2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2829 
    result = updateWeight_result()
2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success is not None:
2833 
      return result.success
2834 
    if result.ex is not None:
2835 
      raise result.ex
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2837 
 
3469 chandransh 2838 
  def changeItem(self, orderId, itemId):
2839 
    """
2840 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2841 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2842 
 
3469 chandransh 2843 
    Parameters:
2844 
     - orderId
2845 
     - itemId
2846 
    """
2847 
    self.send_changeItem(orderId, itemId)
2848 
    return self.recv_changeItem()
2849 
 
2850 
  def send_changeItem(self, orderId, itemId):
2851 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2852 
    args = changeItem_args()
2853 
    args.orderId = orderId
2854 
    args.itemId = itemId
2855 
    args.write(self._oprot)
2856 
    self._oprot.writeMessageEnd()
2857 
    self._oprot.trans.flush()
2858 
 
2859 
  def recv_changeItem(self, ):
2860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2861 
    if mtype == TMessageType.EXCEPTION:
2862 
      x = TApplicationException()
2863 
      x.read(self._iprot)
2864 
      self._iprot.readMessageEnd()
2865 
      raise x
2866 
    result = changeItem_result()
2867 
    result.read(self._iprot)
2868 
    self._iprot.readMessageEnd()
2869 
    if result.success is not None:
2870 
      return result.success
2871 
    if result.ex is not None:
2872 
      raise result.ex
2873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2874 
 
2875 
  def shiftToWarehouse(self, orderId, warehouseId):
2876 
    """
2877 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2878 
 
2879 
    Parameters:
2880 
     - orderId
2881 
     - warehouseId
2882 
    """
2883 
    self.send_shiftToWarehouse(orderId, warehouseId)
2884 
    return self.recv_shiftToWarehouse()
2885 
 
2886 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2887 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2888 
    args = shiftToWarehouse_args()
2889 
    args.orderId = orderId
2890 
    args.warehouseId = warehouseId
2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2895 
  def recv_shiftToWarehouse(self, ):
2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2902 
    result = shiftToWarehouse_result()
2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.success is not None:
2906 
      return result.success
2907 
    if result.ex is not None:
2908 
      raise result.ex
2909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2910 
 
3986 chandransh 2911 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2912 
    """
2913 
    Adds the given delay reason to the given order.
3986 chandransh 2914 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2915 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2916 
 
3553 chandransh 2917 
    Parameters:
2918 
     - orderId
2919 
     - delayReason
3986 chandransh 2920 
     - furtherDelay
3553 chandransh 2921 
    """
3986 chandransh 2922 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2923 
    return self.recv_addDelayReason()
2924 
 
3986 chandransh 2925 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2926 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2927 
    args = addDelayReason_args()
2928 
    args.orderId = orderId
2929 
    args.delayReason = delayReason
3986 chandransh 2930 
    args.furtherDelay = furtherDelay
3553 chandransh 2931 
    args.write(self._oprot)
2932 
    self._oprot.writeMessageEnd()
2933 
    self._oprot.trans.flush()
2934 
 
2935 
  def recv_addDelayReason(self, ):
2936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2937 
    if mtype == TMessageType.EXCEPTION:
2938 
      x = TApplicationException()
2939 
      x.read(self._iprot)
2940 
      self._iprot.readMessageEnd()
2941 
      raise x
2942 
    result = addDelayReason_result()
2943 
    result.read(self._iprot)
2944 
    self._iprot.readMessageEnd()
2945 
    if result.success is not None:
2946 
      return result.success
2947 
    if result.ex is not None:
2948 
      raise result.ex
2949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2950 
 
3956 chandransh 2951 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2952 
    """
2953 
    Marks the COD orders with given AWB nos. as having been processed.
2954 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2955 
 
3956 chandransh 2956 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2957 
    1. There is no order corresponding to an AWB number.
2958 
    2. The captured amount for a payment exceeds the total payment.
2959 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2960 
 
2961 
    Parameters:
2962 
     - collectedAmountMap
2963 
     - xferBy
2964 
     - xferTxnId
2965 
     - xferDate
2966 
    """
2967 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2968 
    return self.recv_reconcileCodCollection()
2969 
 
2970 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2971 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2972 
    args = reconcileCodCollection_args()
2973 
    args.collectedAmountMap = collectedAmountMap
2974 
    args.xferBy = xferBy
2975 
    args.xferTxnId = xferTxnId
2976 
    args.xferDate = xferDate
2977 
    args.write(self._oprot)
2978 
    self._oprot.writeMessageEnd()
2979 
    self._oprot.trans.flush()
2980 
 
2981 
  def recv_reconcileCodCollection(self, ):
2982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2983 
    if mtype == TMessageType.EXCEPTION:
2984 
      x = TApplicationException()
2985 
      x.read(self._iprot)
2986 
      self._iprot.readMessageEnd()
2987 
      raise x
2988 
    result = reconcileCodCollection_result()
2989 
    result.read(self._iprot)
2990 
    self._iprot.readMessageEnd()
2991 
    if result.success is not None:
2992 
      return result.success
2993 
    if result.ex is not None:
2994 
      raise result.ex
2995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2996 
 
4008 mandeep.dh 2997 
  def getTransactionsRequiringExtraProcessing(self, category):
2998 
    """
4065 mandeep.dh 2999 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3000 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3001 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3002 
 
4008 mandeep.dh 3003 
    Parameters:
3004 
     - category
3005 
    """
3006 
    self.send_getTransactionsRequiringExtraProcessing(category)
3007 
    return self.recv_getTransactionsRequiringExtraProcessing()
3008 
 
3009 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3010 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3011 
    args = getTransactionsRequiringExtraProcessing_args()
3012 
    args.category = category
3013 
    args.write(self._oprot)
3014 
    self._oprot.writeMessageEnd()
3015 
    self._oprot.trans.flush()
3016 
 
3017 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3019 
    if mtype == TMessageType.EXCEPTION:
3020 
      x = TApplicationException()
3021 
      x.read(self._iprot)
3022 
      self._iprot.readMessageEnd()
3023 
      raise x
3024 
    result = getTransactionsRequiringExtraProcessing_result()
3025 
    result.read(self._iprot)
3026 
    self._iprot.readMessageEnd()
3027 
    if result.success is not None:
3028 
      return result.success
3029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3030 
 
3031 
  def markTransactionAsProcessed(self, transactionId, category):
3032 
    """
3033 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3034 
    It essentially deletes the transaction id record for a particular
3035 
    processing type category (if present) from DB.
3036 
    This is currently used by CRM application.
4008 mandeep.dh 3037 
 
3038 
    Parameters:
3039 
     - transactionId
3040 
     - category
3041 
    """
3042 
    self.send_markTransactionAsProcessed(transactionId, category)
3043 
    self.recv_markTransactionAsProcessed()
3044 
 
3045 
  def send_markTransactionAsProcessed(self, transactionId, category):
3046 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3047 
    args = markTransactionAsProcessed_args()
3048 
    args.transactionId = transactionId
3049 
    args.category = category
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_markTransactionAsProcessed(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = markTransactionAsProcessed_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    return
3065 
 
4018 chandransh 3066 
  def getItemWiseRiskyOrdersCount(self, ):
3067 
    """
3068 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3069 
    is defined as one whose shipping date is about to expire.
3070 
    """
3071 
    self.send_getItemWiseRiskyOrdersCount()
3072 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3073 
 
4018 chandransh 3074 
  def send_getItemWiseRiskyOrdersCount(self, ):
3075 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3076 
    args = getItemWiseRiskyOrdersCount_args()
3077 
    args.write(self._oprot)
3078 
    self._oprot.writeMessageEnd()
3079 
    self._oprot.trans.flush()
3080 
 
3081 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3083 
    if mtype == TMessageType.EXCEPTION:
3084 
      x = TApplicationException()
3085 
      x.read(self._iprot)
3086 
      self._iprot.readMessageEnd()
3087 
      raise x
3088 
    result = getItemWiseRiskyOrdersCount_result()
3089 
    result.read(self._iprot)
3090 
    self._iprot.readMessageEnd()
3091 
    if result.success is not None:
3092 
      return result.success
3093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3094 
 
4295 varun.gupt 3095 
  def getOrdersForItemIds(self, itemIds):
3096 
    """
3097 
    Returns a list of all orders which have items with given id
3098 
 
3099 
    Parameters:
3100 
     - itemIds
3101 
    """
3102 
    self.send_getOrdersForItemIds(itemIds)
3103 
    return self.recv_getOrdersForItemIds()
3104 
 
3105 
  def send_getOrdersForItemIds(self, itemIds):
3106 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3107 
    args = getOrdersForItemIds_args()
3108 
    args.itemIds = itemIds
3109 
    args.write(self._oprot)
3110 
    self._oprot.writeMessageEnd()
3111 
    self._oprot.trans.flush()
3112 
 
3113 
  def recv_getOrdersForItemIds(self, ):
3114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3115 
    if mtype == TMessageType.EXCEPTION:
3116 
      x = TApplicationException()
3117 
      x.read(self._iprot)
3118 
      self._iprot.readMessageEnd()
3119 
      raise x
3120 
    result = getOrdersForItemIds_result()
3121 
    result.read(self._iprot)
3122 
    self._iprot.readMessageEnd()
3123 
    if result.success is not None:
3124 
      return result.success
3125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3126 
 
4247 rajveer 3127 
  def markOrderCancellationRequestReceived(self, orderId):
3128 
    """
3129 
    Mark order as cancellation request received. If customer sends request of cancellation of
3130 
    a particular order, this method will be called. It will just change status of the order
3131 
    depending on its current status. It also records the previous status, so that we can move
3132 
    back to that status if cancellation request is denied.
4018 chandransh 3133 
 
4247 rajveer 3134 
    Parameters:
3135 
     - orderId
3136 
    """
3137 
    self.send_markOrderCancellationRequestReceived(orderId)
3138 
    self.recv_markOrderCancellationRequestReceived()
3139 
 
3140 
  def send_markOrderCancellationRequestReceived(self, orderId):
3141 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3142 
    args = markOrderCancellationRequestReceived_args()
3143 
    args.orderId = orderId
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_markOrderCancellationRequestReceived(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = markOrderCancellationRequestReceived_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.ex is not None:
3159 
      raise result.ex
3160 
    return
3161 
 
3162 
  def markOrderCancellationRequestConfirmed(self, orderId):
3163 
    """
3164 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3165 
    cancellation request confirmed. After this OM will be able to cancel the order.
3166 
 
3167 
    Parameters:
3168 
     - orderId
3169 
    """
3170 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3171 
    self.recv_markOrderCancellationRequestConfirmed()
3172 
 
3173 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3174 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3175 
    args = markOrderCancellationRequestConfirmed_args()
3176 
    args.orderId = orderId
3177 
    args.write(self._oprot)
3178 
    self._oprot.writeMessageEnd()
3179 
    self._oprot.trans.flush()
3180 
 
3181 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3183 
    if mtype == TMessageType.EXCEPTION:
3184 
      x = TApplicationException()
3185 
      x.read(self._iprot)
3186 
      self._iprot.readMessageEnd()
3187 
      raise x
3188 
    result = markOrderCancellationRequestConfirmed_result()
3189 
    result.read(self._iprot)
3190 
    self._iprot.readMessageEnd()
3191 
    if result.ex is not None:
3192 
      raise result.ex
3193 
    return
3194 
 
3195 
  def markOrderCancellationRequestDenied(self, orderId):
3196 
    """
3197 
    If we decide to not to cancel order, we will move the order ro previous status.
3198 
 
3199 
    Parameters:
3200 
     - orderId
3201 
    """
3202 
    self.send_markOrderCancellationRequestDenied(orderId)
3203 
    self.recv_markOrderCancellationRequestDenied()
3204 
 
3205 
  def send_markOrderCancellationRequestDenied(self, orderId):
3206 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3207 
    args = markOrderCancellationRequestDenied_args()
3208 
    args.orderId = orderId
3209 
    args.write(self._oprot)
3210 
    self._oprot.writeMessageEnd()
3211 
    self._oprot.trans.flush()
3212 
 
3213 
  def recv_markOrderCancellationRequestDenied(self, ):
3214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3215 
    if mtype == TMessageType.EXCEPTION:
3216 
      x = TApplicationException()
3217 
      x.read(self._iprot)
3218 
      self._iprot.readMessageEnd()
3219 
      raise x
3220 
    result = markOrderCancellationRequestDenied_result()
3221 
    result.read(self._iprot)
3222 
    self._iprot.readMessageEnd()
3223 
    if result.ex is not None:
3224 
      raise result.ex
3225 
    return
3226 
 
4258 rajveer 3227 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3228 
    """
4258 rajveer 3229 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3230 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3231 
 
3232 
    Parameters:
4258 rajveer 3233 
     - transactionId
4247 rajveer 3234 
    """
4258 rajveer 3235 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3236 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3237 
 
4258 rajveer 3238 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3239 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3240 
    args = markTransactionAsPaymentFlagRemoved_args()
3241 
    args.transactionId = transactionId
4247 rajveer 3242 
    args.write(self._oprot)
3243 
    self._oprot.writeMessageEnd()
3244 
    self._oprot.trans.flush()
3245 
 
4258 rajveer 3246 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3248 
    if mtype == TMessageType.EXCEPTION:
3249 
      x = TApplicationException()
3250 
      x.read(self._iprot)
3251 
      self._iprot.readMessageEnd()
3252 
      raise x
4258 rajveer 3253 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3254 
    result.read(self._iprot)
3255 
    self._iprot.readMessageEnd()
3256 
    if result.ex is not None:
3257 
      raise result.ex
3258 
    return
3259 
 
4259 anupam.sin 3260 
  def refundTransaction(self, transactionId, refundedBy, reason):
3261 
    """
3262 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3263 
    need to be cancelled
4247 rajveer 3264 
 
4259 anupam.sin 3265 
    Parameters:
3266 
     - transactionId
3267 
     - refundedBy
3268 
     - reason
3269 
    """
3270 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3271 
    self.recv_refundTransaction()
3272 
 
3273 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3274 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3275 
    args = refundTransaction_args()
3276 
    args.transactionId = transactionId
3277 
    args.refundedBy = refundedBy
3278 
    args.reason = reason
3279 
    args.write(self._oprot)
3280 
    self._oprot.writeMessageEnd()
3281 
    self._oprot.trans.flush()
3282 
 
3283 
  def recv_refundTransaction(self, ):
3284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3285 
    if mtype == TMessageType.EXCEPTION:
3286 
      x = TApplicationException()
3287 
      x.read(self._iprot)
3288 
      self._iprot.readMessageEnd()
3289 
      raise x
3290 
    result = refundTransaction_result()
3291 
    result.read(self._iprot)
3292 
    self._iprot.readMessageEnd()
3293 
    if result.ex is not None:
3294 
      raise result.ex
3295 
    return
3296 
 
4324 mandeep.dh 3297 
  def updateShipmentAddress(self, orderId, addressId):
3298 
    """
3299 
    Updates shipment address of an order. Delivery and shipping date estimates
3300 
    etc. are also updated here.
3301 
 
3302 
    Throws TransactionServiceException in case address change is not
3303 
    possible due to certain reasons such as new pincode in address is
3304 
    not serviceable etc.
3305 
 
3306 
    Parameters:
3307 
     - orderId
3308 
     - addressId
3309 
    """
3310 
    self.send_updateShipmentAddress(orderId, addressId)
3311 
    self.recv_updateShipmentAddress()
3312 
 
3313 
  def send_updateShipmentAddress(self, orderId, addressId):
3314 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3315 
    args = updateShipmentAddress_args()
3316 
    args.orderId = orderId
3317 
    args.addressId = addressId
3318 
    args.write(self._oprot)
3319 
    self._oprot.writeMessageEnd()
3320 
    self._oprot.trans.flush()
3321 
 
3322 
  def recv_updateShipmentAddress(self, ):
3323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3324 
    if mtype == TMessageType.EXCEPTION:
3325 
      x = TApplicationException()
3326 
      x.read(self._iprot)
3327 
      self._iprot.readMessageEnd()
3328 
      raise x
3329 
    result = updateShipmentAddress_result()
3330 
    result.read(self._iprot)
3331 
    self._iprot.readMessageEnd()
3332 
    if result.ex is not None:
3333 
      raise result.ex
3334 
    return
3335 
 
4285 rajveer 3336 
  def acceptOrdersForItemId(self, itemId, inventory):
3337 
    """
3338 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3339 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3340 
 
4285 rajveer 3341 
    Parameters:
3342 
     - itemId
3343 
     - inventory
3344 
    """
3345 
    self.send_acceptOrdersForItemId(itemId, inventory)
3346 
    return self.recv_acceptOrdersForItemId()
3347 
 
3348 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3349 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3350 
    args = acceptOrdersForItemId_args()
3351 
    args.itemId = itemId
3352 
    args.inventory = inventory
3353 
    args.write(self._oprot)
3354 
    self._oprot.writeMessageEnd()
3355 
    self._oprot.trans.flush()
3356 
 
3357 
  def recv_acceptOrdersForItemId(self, ):
3358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3359 
    if mtype == TMessageType.EXCEPTION:
3360 
      x = TApplicationException()
3361 
      x.read(self._iprot)
3362 
      self._iprot.readMessageEnd()
3363 
      raise x
3364 
    result = acceptOrdersForItemId_result()
3365 
    result.read(self._iprot)
3366 
    self._iprot.readMessageEnd()
3367 
    if result.success is not None:
3368 
      return result.success
3369 
    if result.ex is not None:
3370 
      raise result.ex
3371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3372 
 
4369 rajveer 3373 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3374 
    """
3375 
    Parameters:
3376 
     - vendorId
3377 
     - itemId
3378 
     - quantity
3379 
     - estimate
4369 rajveer 3380 
     - isReminder
4303 rajveer 3381 
    """
4369 rajveer 3382 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3383 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3384 
 
4369 rajveer 3385 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3386 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3387 
    args = markOrdersAsPORaised_args()
3388 
    args.vendorId = vendorId
3389 
    args.itemId = itemId
3390 
    args.quantity = quantity
3391 
    args.estimate = estimate
4369 rajveer 3392 
    args.isReminder = isReminder
4303 rajveer 3393 
    args.write(self._oprot)
3394 
    self._oprot.writeMessageEnd()
3395 
    self._oprot.trans.flush()
3396 
 
3397 
  def recv_markOrdersAsPORaised(self, ):
3398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3399 
    if mtype == TMessageType.EXCEPTION:
3400 
      x = TApplicationException()
3401 
      x.read(self._iprot)
3402 
      self._iprot.readMessageEnd()
3403 
      raise x
3404 
    result = markOrdersAsPORaised_result()
3405 
    result.read(self._iprot)
3406 
    self._iprot.readMessageEnd()
3407 
    if result.ex is not None:
3408 
      raise result.ex
3409 
    return
3410 
 
4369 rajveer 3411 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3412 
    """
3413 
    Parameters:
3414 
     - vendorId
3415 
     - itemId
3416 
     - quantity
3417 
     - estimate
4369 rajveer 3418 
     - isReminder
4303 rajveer 3419 
    """
4369 rajveer 3420 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3421 
    self.recv_markOrdersAsReversalInitiated()
3422 
 
4369 rajveer 3423 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3424 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3425 
    args = markOrdersAsReversalInitiated_args()
3426 
    args.vendorId = vendorId
3427 
    args.itemId = itemId
3428 
    args.quantity = quantity
3429 
    args.estimate = estimate
4369 rajveer 3430 
    args.isReminder = isReminder
4303 rajveer 3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_markOrdersAsReversalInitiated(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = markOrdersAsReversalInitiated_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    if result.ex is not None:
3446 
      raise result.ex
3447 
    return
3448 
 
4369 rajveer 3449 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3450 
    """
3451 
    Parameters:
3452 
     - vendorId
3453 
     - itemId
3454 
     - quantity
3455 
     - estimate
4369 rajveer 3456 
     - isReminder
4303 rajveer 3457 
    """
4369 rajveer 3458 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3459 
    self.recv_markOrdersAsNotAvailabke()
3460 
 
4369 rajveer 3461 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3462 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3463 
    args = markOrdersAsNotAvailabke_args()
3464 
    args.vendorId = vendorId
3465 
    args.itemId = itemId
3466 
    args.quantity = quantity
3467 
    args.estimate = estimate
4369 rajveer 3468 
    args.isReminder = isReminder
4303 rajveer 3469 
    args.write(self._oprot)
3470 
    self._oprot.writeMessageEnd()
3471 
    self._oprot.trans.flush()
3472 
 
3473 
  def recv_markOrdersAsNotAvailabke(self, ):
3474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3475 
    if mtype == TMessageType.EXCEPTION:
3476 
      x = TApplicationException()
3477 
      x.read(self._iprot)
3478 
      self._iprot.readMessageEnd()
3479 
      raise x
3480 
    result = markOrdersAsNotAvailabke_result()
3481 
    result.read(self._iprot)
3482 
    self._iprot.readMessageEnd()
3483 
    if result.ex is not None:
3484 
      raise result.ex
3485 
    return
3486 
 
4369 rajveer 3487 
  def markOrdersAsTimeout(self, vendorId):
3488 
    """
3489 
    Parameters:
3490 
     - vendorId
3491 
    """
3492 
    self.send_markOrdersAsTimeout(vendorId)
3493 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3494 
 
4369 rajveer 3495 
  def send_markOrdersAsTimeout(self, vendorId):
3496 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3497 
    args = markOrdersAsTimeout_args()
3498 
    args.vendorId = vendorId
3499 
    args.write(self._oprot)
3500 
    self._oprot.writeMessageEnd()
3501 
    self._oprot.trans.flush()
3502 
 
3503 
  def recv_markOrdersAsTimeout(self, ):
3504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3505 
    if mtype == TMessageType.EXCEPTION:
3506 
      x = TApplicationException()
3507 
      x.read(self._iprot)
3508 
      self._iprot.readMessageEnd()
3509 
      raise x
3510 
    result = markOrdersAsTimeout_result()
3511 
    result.read(self._iprot)
3512 
    self._iprot.readMessageEnd()
3513 
    if result.success is not None:
3514 
      return result.success
3515 
    if result.ex is not None:
3516 
      raise result.ex
3517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3518 
 
4386 anupam.sin 3519 
  def getOrderForAwb(self, awb):
3520 
    """
3521 
    Returns the order corresponding to an AWB number
4369 rajveer 3522 
 
4386 anupam.sin 3523 
    Parameters:
3524 
     - awb
3525 
    """
3526 
    self.send_getOrderForAwb(awb)
3527 
    return self.recv_getOrderForAwb()
3528 
 
3529 
  def send_getOrderForAwb(self, awb):
3530 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3531 
    args = getOrderForAwb_args()
3532 
    args.awb = awb
3533 
    args.write(self._oprot)
3534 
    self._oprot.writeMessageEnd()
3535 
    self._oprot.trans.flush()
3536 
 
3537 
  def recv_getOrderForAwb(self, ):
3538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3539 
    if mtype == TMessageType.EXCEPTION:
3540 
      x = TApplicationException()
3541 
      x.read(self._iprot)
3542 
      self._iprot.readMessageEnd()
3543 
      raise x
3544 
    result = getOrderForAwb_result()
3545 
    result.read(self._iprot)
3546 
    self._iprot.readMessageEnd()
3547 
    if result.success is not None:
3548 
      return result.success
3549 
    if result.ex is not None:
3550 
      raise result.ex
3551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3552 
 
3553 
 
3376 rajveer 3554 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3555 
  def __init__(self, handler):
3376 rajveer 3556 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3557 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3558 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3559 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3560 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3561 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3562 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3563 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3564 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3565 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3566 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3567 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3568 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3569 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3570 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3571 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3572 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3573 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3574 
    self._processMap["createOrder"] = Processor.process_createOrder
3575 
    self._processMap["getOrder"] = Processor.process_getOrder
3576 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3577 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3578 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3579 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3580 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3581 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3582 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3583 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3584 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3585 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3586 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3587 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3588 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3589 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3590 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3591 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3592 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3593 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3594 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3595 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3596 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3597 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3598 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3599 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
2536 chandransh 3600 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3601 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3602 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3603 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3604 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3605 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3606 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3607 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3608 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3609 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3610 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3611 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3612 
    self._processMap["changeItem"] = Processor.process_changeItem
3613 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3614 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3615 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3616 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3617 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3618 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3619 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3620 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3621 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3622 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3623 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3624 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3625 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3626 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3627 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3628 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3629 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3630 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3631 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3632 
 
3633 
  def process(self, iprot, oprot):
3634 
    (name, type, seqid) = iprot.readMessageBegin()
3635 
    if name not in self._processMap:
3636 
      iprot.skip(TType.STRUCT)
3637 
      iprot.readMessageEnd()
3638 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3639 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3640 
      x.write(oprot)
3641 
      oprot.writeMessageEnd()
3642 
      oprot.trans.flush()
3643 
      return
3644 
    else:
3645 
      self._processMap[name](self, seqid, iprot, oprot)
3646 
    return True
3647 
 
3648 
  def process_createTransaction(self, seqid, iprot, oprot):
3649 
    args = createTransaction_args()
3650 
    args.read(iprot)
3651 
    iprot.readMessageEnd()
3652 
    result = createTransaction_result()
3653 
    try:
132 ashish 3654 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3655 
    except TransactionServiceException, ex:
3656 
      result.ex = ex
3657 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3658 
    result.write(oprot)
3659 
    oprot.writeMessageEnd()
3660 
    oprot.trans.flush()
3661 
 
3662 
  def process_getTransaction(self, seqid, iprot, oprot):
3663 
    args = getTransaction_args()
3664 
    args.read(iprot)
3665 
    iprot.readMessageEnd()
3666 
    result = getTransaction_result()
3667 
    try:
3668 
      result.success = self._handler.getTransaction(args.id)
3669 
    except TransactionServiceException, ex:
3670 
      result.ex = ex
3671 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3672 
    result.write(oprot)
3673 
    oprot.writeMessageEnd()
3674 
    oprot.trans.flush()
3675 
 
3676 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3677 
    args = getTransactionsForCustomer_args()
3678 
    args.read(iprot)
3679 
    iprot.readMessageEnd()
3680 
    result = getTransactionsForCustomer_result()
3681 
    try:
3682 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3683 
    except TransactionServiceException, ex:
3684 
      result.ex = ex
3685 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3686 
    result.write(oprot)
3687 
    oprot.writeMessageEnd()
3688 
    oprot.trans.flush()
3689 
 
132 ashish 3690 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3691 
    args = getTransactionsForShoppingCartId_args()
3692 
    args.read(iprot)
3693 
    iprot.readMessageEnd()
3694 
    result = getTransactionsForShoppingCartId_result()
3695 
    try:
3696 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3697 
    except TransactionServiceException, ex:
3698 
      result.ex = ex
3699 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3700 
    result.write(oprot)
3701 
    oprot.writeMessageEnd()
3702 
    oprot.trans.flush()
3703 
 
94 ashish 3704 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3705 
    args = getTransactionStatus_args()
3706 
    args.read(iprot)
3707 
    iprot.readMessageEnd()
3708 
    result = getTransactionStatus_result()
3709 
    try:
3710 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3711 
    except TransactionServiceException, ex:
3712 
      result.ex = ex
3713 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3714 
    result.write(oprot)
3715 
    oprot.writeMessageEnd()
3716 
    oprot.trans.flush()
3717 
 
3718 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3719 
    args = changeTransactionStatus_args()
3720 
    args.read(iprot)
3721 
    iprot.readMessageEnd()
3722 
    result = changeTransactionStatus_result()
3723 
    try:
3724 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3725 
    except TransactionServiceException, ex:
3726 
      result.ex = ex
3727 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3728 
    result.write(oprot)
3729 
    oprot.writeMessageEnd()
3730 
    oprot.trans.flush()
3731 
 
1398 varun.gupt 3732 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3733 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3734 
    args.read(iprot)
3735 
    iprot.readMessageEnd()
1398 varun.gupt 3736 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3737 
    try:
1398 varun.gupt 3738 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3739 
    except TransactionServiceException, ex:
3740 
      result.ex = ex
1398 varun.gupt 3741 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3742 
    result.write(oprot)
3743 
    oprot.writeMessageEnd()
3744 
    oprot.trans.flush()
3745 
 
483 rajveer 3746 
  def process_getAllOrders(self, seqid, iprot, oprot):
3747 
    args = getAllOrders_args()
94 ashish 3748 
    args.read(iprot)
3749 
    iprot.readMessageEnd()
483 rajveer 3750 
    result = getAllOrders_result()
94 ashish 3751 
    try:
483 rajveer 3752 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3753 
    except TransactionServiceException, ex:
3754 
      result.ex = ex
483 rajveer 3755 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3756 
    result.write(oprot)
3757 
    oprot.writeMessageEnd()
3758 
    oprot.trans.flush()
3759 
 
4133 chandransh 3760 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3761 
    args = getOrdersInBatch_args()
3762 
    args.read(iprot)
3763 
    iprot.readMessageEnd()
3764 
    result = getOrdersInBatch_result()
3765 
    try:
3766 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3767 
    except TransactionServiceException, ex:
3768 
      result.ex = ex
3769 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3770 
    result.write(oprot)
3771 
    oprot.writeMessageEnd()
3772 
    oprot.trans.flush()
3773 
 
3774 
  def process_getOrderCount(self, seqid, iprot, oprot):
3775 
    args = getOrderCount_args()
3776 
    args.read(iprot)
3777 
    iprot.readMessageEnd()
3778 
    result = getOrderCount_result()
3779 
    try:
3780 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3781 
    except TransactionServiceException, ex:
3782 
      result.ex = ex
3783 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3784 
    result.write(oprot)
3785 
    oprot.writeMessageEnd()
3786 
    oprot.trans.flush()
3787 
 
999 varun.gupt 3788 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3789 
    args = getOrdersByBillingDate_args()
3790 
    args.read(iprot)
3791 
    iprot.readMessageEnd()
3792 
    result = getOrdersByBillingDate_result()
3793 
    try:
3794 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3795 
    except TransactionServiceException, ex:
3796 
      result.ex = ex
3797 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3798 
    result.write(oprot)
3799 
    oprot.writeMessageEnd()
3800 
    oprot.trans.flush()
3801 
 
3427 chandransh 3802 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3803 
    args = getOrdersByShippingDate_args()
3804 
    args.read(iprot)
3805 
    iprot.readMessageEnd()
3806 
    result = getOrdersByShippingDate_result()
3807 
    try:
3451 chandransh 3808 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3809 
    except TransactionServiceException, ex:
3810 
      result.ex = ex
3811 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3812 
    result.write(oprot)
3813 
    oprot.writeMessageEnd()
3814 
    oprot.trans.flush()
3815 
 
1382 varun.gupt 3816 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3817 
    args = getReturnableOrdersForCustomer_args()
3818 
    args.read(iprot)
3819 
    iprot.readMessageEnd()
3820 
    result = getReturnableOrdersForCustomer_result()
3821 
    try:
3822 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3823 
    except TransactionServiceException, ex:
3824 
      result.ex = ex
3825 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3826 
    result.write(oprot)
3827 
    oprot.writeMessageEnd()
3828 
    oprot.trans.flush()
3829 
 
3830 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3831 
    args = getCancellableOrdersForCustomer_args()
3832 
    args.read(iprot)
3833 
    iprot.readMessageEnd()
3834 
    result = getCancellableOrdersForCustomer_result()
3835 
    try:
3836 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3837 
    except TransactionServiceException, ex:
3838 
      result.ex = ex
3839 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3840 
    result.write(oprot)
3841 
    oprot.writeMessageEnd()
3842 
    oprot.trans.flush()
3843 
 
483 rajveer 3844 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3845 
    args = changeOrderStatus_args()
94 ashish 3846 
    args.read(iprot)
3847 
    iprot.readMessageEnd()
483 rajveer 3848 
    result = changeOrderStatus_result()
94 ashish 3849 
    try:
483 rajveer 3850 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3851 
    except TransactionServiceException, ex:
3852 
      result.ex = ex
483 rajveer 3853 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3854 
    result.write(oprot)
3855 
    oprot.writeMessageEnd()
3856 
    oprot.trans.flush()
3857 
 
483 rajveer 3858 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3859 
    args = getOrdersForTransaction_args()
94 ashish 3860 
    args.read(iprot)
3861 
    iprot.readMessageEnd()
483 rajveer 3862 
    result = getOrdersForTransaction_result()
94 ashish 3863 
    try:
1528 ankur.sing 3864 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3865 
    except TransactionServiceException, ex:
3866 
      result.ex = ex
483 rajveer 3867 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3868 
    result.write(oprot)
3869 
    oprot.writeMessageEnd()
3870 
    oprot.trans.flush()
3871 
 
483 rajveer 3872 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3873 
    args = getOrdersForCustomer_args()
94 ashish 3874 
    args.read(iprot)
3875 
    iprot.readMessageEnd()
483 rajveer 3876 
    result = getOrdersForCustomer_result()
94 ashish 3877 
    try:
3014 chandransh 3878 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3879 
    except TransactionServiceException, ex:
3880 
      result.ex = ex
483 rajveer 3881 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3882 
    result.write(oprot)
3883 
    oprot.writeMessageEnd()
3884 
    oprot.trans.flush()
3885 
 
483 rajveer 3886 
  def process_createOrder(self, seqid, iprot, oprot):
3887 
    args = createOrder_args()
94 ashish 3888 
    args.read(iprot)
3889 
    iprot.readMessageEnd()
483 rajveer 3890 
    result = createOrder_result()
94 ashish 3891 
    try:
483 rajveer 3892 
      result.success = self._handler.createOrder(args.order)
94 ashish 3893 
    except TransactionServiceException, ex:
3894 
      result.ex = ex
483 rajveer 3895 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3896 
    result.write(oprot)
3897 
    oprot.writeMessageEnd()
3898 
    oprot.trans.flush()
3899 
 
483 rajveer 3900 
  def process_getOrder(self, seqid, iprot, oprot):
3901 
    args = getOrder_args()
94 ashish 3902 
    args.read(iprot)
3903 
    iprot.readMessageEnd()
483 rajveer 3904 
    result = getOrder_result()
94 ashish 3905 
    try:
483 rajveer 3906 
      result.success = self._handler.getOrder(args.id)
94 ashish 3907 
    except TransactionServiceException, ex:
3908 
      result.ex = ex
483 rajveer 3909 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3910 
    result.write(oprot)
3911 
    oprot.writeMessageEnd()
3912 
    oprot.trans.flush()
3913 
 
483 rajveer 3914 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3915 
    args = getLineItemsForOrder_args()
94 ashish 3916 
    args.read(iprot)
3917 
    iprot.readMessageEnd()
483 rajveer 3918 
    result = getLineItemsForOrder_result()
94 ashish 3919 
    try:
483 rajveer 3920 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3921 
    except TransactionServiceException, ex:
3922 
      result.ex = ex
483 rajveer 3923 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3924 
    result.write(oprot)
3925 
    oprot.writeMessageEnd()
3926 
    oprot.trans.flush()
3927 
 
1528 ankur.sing 3928 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3929 
    args = getOrderForCustomer_args()
3930 
    args.read(iprot)
3931 
    iprot.readMessageEnd()
3932 
    result = getOrderForCustomer_result()
3933 
    try:
3934 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3935 
    except TransactionServiceException, ex:
3936 
      result.ex = ex
3937 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3938 
    result.write(oprot)
3939 
    oprot.writeMessageEnd()
3940 
    oprot.trans.flush()
3941 
 
3064 chandransh 3942 
  def process_getAlerts(self, seqid, iprot, oprot):
3943 
    args = getAlerts_args()
3944 
    args.read(iprot)
3945 
    iprot.readMessageEnd()
3946 
    result = getAlerts_result()
4444 rajveer 3947 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 3948 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3949 
    result.write(oprot)
3950 
    oprot.writeMessageEnd()
3951 
    oprot.trans.flush()
3952 
 
4394 rajveer 3953 
  def process_addAlert(self, seqid, iprot, oprot):
3954 
    args = addAlert_args()
3064 chandransh 3955 
    args.read(iprot)
3956 
    iprot.readMessageEnd()
4394 rajveer 3957 
    result = addAlert_result()
4444 rajveer 3958 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 3959 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 3960 
    result.write(oprot)
3961 
    oprot.writeMessageEnd()
3962 
    oprot.trans.flush()
3963 
 
4444 rajveer 3964 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
3965 
    args = markAlertsAsSeen_args()
3966 
    args.read(iprot)
3967 
    iprot.readMessageEnd()
3968 
    result = markAlertsAsSeen_result()
3969 
    self._handler.markAlertsAsSeen(args.warehouseId)
3970 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
3971 
    result.write(oprot)
3972 
    oprot.writeMessageEnd()
3973 
    oprot.trans.flush()
3974 
 
3064 chandransh 3975 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3976 
    args = getValidOrderCount_args()
3977 
    args.read(iprot)
3978 
    iprot.readMessageEnd()
3979 
    result = getValidOrderCount_result()
3980 
    result.success = self._handler.getValidOrderCount()
3981 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3982 
    result.write(oprot)
3983 
    oprot.writeMessageEnd()
3984 
    oprot.trans.flush()
3985 
 
3986 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3987 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3988 
    args.read(iprot)
3989 
    iprot.readMessageEnd()
3990 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3991 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3992 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3993 
    result.write(oprot)
3994 
    oprot.writeMessageEnd()
3995 
    oprot.trans.flush()
3996 
 
3997 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3998 
    args = getValidOrdersAmountRange_args()
3999 
    args.read(iprot)
4000 
    iprot.readMessageEnd()
4001 
    result = getValidOrdersAmountRange_result()
4002 
    result.success = self._handler.getValidOrdersAmountRange()
4003 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4004 
    result.write(oprot)
4005 
    oprot.writeMessageEnd()
4006 
    oprot.trans.flush()
4007 
 
4008 
  def process_getValidOrders(self, seqid, iprot, oprot):
4009 
    args = getValidOrders_args()
4010 
    args.read(iprot)
4011 
    iprot.readMessageEnd()
4012 
    result = getValidOrders_result()
4013 
    result.success = self._handler.getValidOrders(args.limit)
4014 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4015 
    result.write(oprot)
4016 
    oprot.writeMessageEnd()
4017 
    oprot.trans.flush()
4018 
 
1220 chandransh 4019 
  def process_batchOrders(self, seqid, iprot, oprot):
4020 
    args = batchOrders_args()
4021 
    args.read(iprot)
4022 
    iprot.readMessageEnd()
4023 
    result = batchOrders_result()
4024 
    try:
4025 
      result.success = self._handler.batchOrders(args.warehouseId)
4026 
    except TransactionServiceException, ex:
4027 
      result.ex = ex
4028 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4029 
    result.write(oprot)
4030 
    oprot.writeMessageEnd()
4031 
    oprot.trans.flush()
4032 
 
1208 chandransh 4033 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4034 
    args = markOrderAsOutOfStock_args()
4035 
    args.read(iprot)
4036 
    iprot.readMessageEnd()
4037 
    result = markOrderAsOutOfStock_result()
4038 
    try:
4039 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4040 
    except TransactionServiceException, ex:
4041 
      result.ex = ex
4042 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4043 
    result.write(oprot)
4044 
    oprot.writeMessageEnd()
4045 
    oprot.trans.flush()
4046 
 
3064 chandransh 4047 
  def process_verifyOrder(self, seqid, iprot, oprot):
4048 
    args = verifyOrder_args()
759 chandransh 4049 
    args.read(iprot)
4050 
    iprot.readMessageEnd()
3064 chandransh 4051 
    result = verifyOrder_result()
759 chandransh 4052 
    try:
3064 chandransh 4053 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4054 
    except TransactionServiceException, ex:
4055 
      result.ex = ex
3064 chandransh 4056 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4057 
    result.write(oprot)
4058 
    oprot.writeMessageEnd()
4059 
    oprot.trans.flush()
4060 
 
3064 chandransh 4061 
  def process_acceptOrder(self, seqid, iprot, oprot):
4062 
    args = acceptOrder_args()
1113 chandransh 4063 
    args.read(iprot)
4064 
    iprot.readMessageEnd()
3064 chandransh 4065 
    result = acceptOrder_result()
1113 chandransh 4066 
    try:
3064 chandransh 4067 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4068 
    except TransactionServiceException, ex:
4069 
      result.ex = ex
3064 chandransh 4070 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4071 
    result.write(oprot)
4072 
    oprot.writeMessageEnd()
4073 
    oprot.trans.flush()
4074 
 
3064 chandransh 4075 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4076 
    args = addBillingDetails_args()
1135 chandransh 4077 
    args.read(iprot)
4078 
    iprot.readMessageEnd()
3064 chandransh 4079 
    result = addBillingDetails_result()
1135 chandransh 4080 
    try:
4283 anupam.sin 4081 
      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 4082 
    except TransactionServiceException, ex:
4083 
      result.ex = ex
3064 chandransh 4084 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4088 
 
3064 chandransh 4089 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4090 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
3064 chandransh 4093 
    result = markOrdersAsManifested_result()
4094 
    try:
4095 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4096 
    except TransactionServiceException, ex:
4097 
      result.ex = ex
4098 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4099 
    result.write(oprot)
4100 
    oprot.writeMessageEnd()
4101 
    oprot.trans.flush()
4102 
 
4410 rajveer 4103 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4104 
    args = markOrdersAsShippedFromWarehouse_args()
4105 
    args.read(iprot)
4106 
    iprot.readMessageEnd()
4107 
    result = markOrdersAsShippedFromWarehouse_result()
4108 
    try:
4109 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4110 
    except TransactionServiceException, ex:
4111 
      result.ex = ex
4112 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4113 
    result.write(oprot)
4114 
    oprot.writeMessageEnd()
4115 
    oprot.trans.flush()
4116 
 
3064 chandransh 4117 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4118 
    args = markOrdersAsPickedUp_args()
304 ashish 4119 
    args.read(iprot)
4120 
    iprot.readMessageEnd()
3064 chandransh 4121 
    result = markOrdersAsPickedUp_result()
4122 
    try:
4123 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4124 
    except TransactionServiceException, ex:
4125 
      result.ex = ex
4126 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4127 
    result.write(oprot)
4128 
    oprot.writeMessageEnd()
4129 
    oprot.trans.flush()
94 ashish 4130 
 
3064 chandransh 4131 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4132 
    args = markOrdersAsDelivered_args()
304 ashish 4133 
    args.read(iprot)
4134 
    iprot.readMessageEnd()
3064 chandransh 4135 
    result = markOrdersAsDelivered_result()
4136 
    try:
4137 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4138 
    except TransactionServiceException, ex:
4139 
      result.ex = ex
4140 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4141 
    result.write(oprot)
4142 
    oprot.writeMessageEnd()
4143 
    oprot.trans.flush()
4144 
 
3064 chandransh 4145 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4146 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4147 
    args.read(iprot)
4148 
    iprot.readMessageEnd()
3064 chandransh 4149 
    result = markOrdersAsFailed_result()
4150 
    try:
4151 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4152 
    except TransactionServiceException, ex:
4153 
      result.ex = ex
4154 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4155 
    result.write(oprot)
4156 
    oprot.writeMessageEnd()
4157 
    oprot.trans.flush()
304 ashish 4158 
 
3064 chandransh 4159 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4160 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4161 
    args.read(iprot)
4162 
    iprot.readMessageEnd()
3064 chandransh 4163 
    result = updateNonDeliveryReason_result()
4164 
    try:
4165 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4166 
    except TransactionServiceException, ex:
4167 
      result.ex = ex
4168 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4169 
    result.write(oprot)
4170 
    oprot.writeMessageEnd()
4171 
    oprot.trans.flush()
1596 ankur.sing 4172 
 
3064 chandransh 4173 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4174 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4175 
    args.read(iprot)
4176 
    iprot.readMessageEnd()
3064 chandransh 4177 
    result = getUndeliveredOrders_result()
4178 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4179 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4180 
    result.write(oprot)
4181 
    oprot.writeMessageEnd()
4182 
    oprot.trans.flush()
4183 
 
2536 chandransh 4184 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4185 
    args = toggleDOAFlag_args()
4186 
    args.read(iprot)
4187 
    iprot.readMessageEnd()
4188 
    result = toggleDOAFlag_result()
4189 
    try:
4190 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4191 
    except TransactionServiceException, ex:
4192 
      result.ex = ex
4193 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4194 
    result.write(oprot)
4195 
    oprot.writeMessageEnd()
4196 
    oprot.trans.flush()
1886 ankur.sing 4197 
 
4454 rajveer 4198 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4199 
    args = markOrderDoaRequestReceived_args()
4200 
    args.read(iprot)
4201 
    iprot.readMessageEnd()
4202 
    result = markOrderDoaRequestReceived_result()
4203 
    try:
4204 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4205 
    except TransactionServiceException, ex:
4206 
      result.ex = ex
4207 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
4211 
 
4212 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4213 
    args = markOrderDoaRequestAuthorized_args()
4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
4216 
    result = markOrderDoaRequestAuthorized_result()
4217 
    try:
4218 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4219 
    except TransactionServiceException, ex:
4220 
      result.ex = ex
4221 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4222 
    result.write(oprot)
4223 
    oprot.writeMessageEnd()
4224 
    oprot.trans.flush()
4225 
 
2536 chandransh 4226 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4227 
    args = requestPickupNumber_args()
4228 
    args.read(iprot)
4229 
    iprot.readMessageEnd()
4230 
    result = requestPickupNumber_result()
4231 
    try:
4232 
      result.success = self._handler.requestPickupNumber(args.orderId)
4233 
    except TransactionServiceException, ex:
4234 
      result.ex = ex
4235 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4236 
    result.write(oprot)
4237 
    oprot.writeMessageEnd()
4238 
    oprot.trans.flush()
4239 
 
4240 
  def process_authorizePickup(self, seqid, iprot, oprot):
4241 
    args = authorizePickup_args()
4242 
    args.read(iprot)
4243 
    iprot.readMessageEnd()
4244 
    result = authorizePickup_result()
4245 
    try:
4246 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4247 
    except TransactionServiceException, ex:
4248 
      result.ex = ex
4249 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4250 
    result.write(oprot)
4251 
    oprot.writeMessageEnd()
4252 
    oprot.trans.flush()
4253 
 
2764 chandransh 4254 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4255 
    args = markDoasAsPickedUp_args()
4256 
    args.read(iprot)
4257 
    iprot.readMessageEnd()
4258 
    result = markDoasAsPickedUp_result()
4259 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4260 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4261 
    result.write(oprot)
4262 
    oprot.writeMessageEnd()
4263 
    oprot.trans.flush()
4264 
 
2616 chandransh 4265 
  def process_receiveReturn(self, seqid, iprot, oprot):
4266 
    args = receiveReturn_args()
2591 chandransh 4267 
    args.read(iprot)
4268 
    iprot.readMessageEnd()
2616 chandransh 4269 
    result = receiveReturn_result()
2591 chandransh 4270 
    try:
4479 rajveer 4271 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4272 
    except TransactionServiceException, ex:
4273 
      result.ex = ex
2616 chandransh 4274 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4275 
    result.write(oprot)
4276 
    oprot.writeMessageEnd()
4277 
    oprot.trans.flush()
2536 chandransh 4278 
 
2591 chandransh 4279 
  def process_validateDoa(self, seqid, iprot, oprot):
4280 
    args = validateDoa_args()
4281 
    args.read(iprot)
4282 
    iprot.readMessageEnd()
4283 
    result = validateDoa_result()
4284 
    try:
4285 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4286 
    except TransactionServiceException, ex:
4287 
      result.ex = ex
4288 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4289 
    result.write(oprot)
4290 
    oprot.writeMessageEnd()
4291 
    oprot.trans.flush()
4292 
 
2616 chandransh 4293 
  def process_reshipOrder(self, seqid, iprot, oprot):
4294 
    args = reshipOrder_args()
4295 
    args.read(iprot)
4296 
    iprot.readMessageEnd()
4297 
    result = reshipOrder_result()
4298 
    try:
4299 
      result.success = self._handler.reshipOrder(args.orderId)
4300 
    except TransactionServiceException, ex:
4301 
      result.ex = ex
4302 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4303 
    result.write(oprot)
4304 
    oprot.writeMessageEnd()
4305 
    oprot.trans.flush()
2591 chandransh 4306 
 
2616 chandransh 4307 
  def process_refundOrder(self, seqid, iprot, oprot):
4308 
    args = refundOrder_args()
4309 
    args.read(iprot)
4310 
    iprot.readMessageEnd()
4311 
    result = refundOrder_result()
4312 
    try:
3226 chandransh 4313 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4314 
    except TransactionServiceException, ex:
4315 
      result.ex = ex
4316 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4317 
    result.write(oprot)
4318 
    oprot.writeMessageEnd()
4319 
    oprot.trans.flush()
4320 
 
2690 chandransh 4321 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4322 
    args = getReturnOrders_args()
4323 
    args.read(iprot)
4324 
    iprot.readMessageEnd()
4325 
    result = getReturnOrders_result()
4326 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4327 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4328 
    result.write(oprot)
4329 
    oprot.writeMessageEnd()
4330 
    oprot.trans.flush()
2616 chandransh 4331 
 
2700 chandransh 4332 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4333 
    args = getReturnOrder_args()
4334 
    args.read(iprot)
4335 
    iprot.readMessageEnd()
4336 
    result = getReturnOrder_result()
4337 
    try:
4338 
      result.success = self._handler.getReturnOrder(args.id)
4339 
    except TransactionServiceException, ex:
4340 
      result.ex = ex
4341 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4342 
    result.write(oprot)
4343 
    oprot.writeMessageEnd()
4344 
    oprot.trans.flush()
4345 
 
2690 chandransh 4346 
  def process_processReturn(self, seqid, iprot, oprot):
4347 
    args = processReturn_args()
4348 
    args.read(iprot)
4349 
    iprot.readMessageEnd()
4350 
    result = processReturn_result()
4351 
    try:
4352 
      self._handler.processReturn(args.returnOrderId)
4353 
    except TransactionServiceException, ex:
4354 
      result.ex = ex
4355 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4359 
 
2819 chandransh 4360 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4361 
    args = createPurchaseOrder_args()
4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
4364 
    result = createPurchaseOrder_result()
4365 
    try:
4366 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4367 
    except TransactionServiceException, ex:
4368 
      result.ex = ex
4369 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
2690 chandransh 4373 
 
3451 chandransh 4374 
  def process_updateWeight(self, seqid, iprot, oprot):
4375 
    args = updateWeight_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = updateWeight_result()
4379 
    try:
4380 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4381 
    except TransactionServiceException, ex:
4382 
      result.ex = ex
4383 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4384 
    result.write(oprot)
4385 
    oprot.writeMessageEnd()
4386 
    oprot.trans.flush()
2819 chandransh 4387 
 
3469 chandransh 4388 
  def process_changeItem(self, seqid, iprot, oprot):
4389 
    args = changeItem_args()
4390 
    args.read(iprot)
4391 
    iprot.readMessageEnd()
4392 
    result = changeItem_result()
4393 
    try:
4394 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4395 
    except TransactionServiceException, ex:
4396 
      result.ex = ex
4397 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4398 
    result.write(oprot)
4399 
    oprot.writeMessageEnd()
4400 
    oprot.trans.flush()
3451 chandransh 4401 
 
3469 chandransh 4402 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4403 
    args = shiftToWarehouse_args()
4404 
    args.read(iprot)
4405 
    iprot.readMessageEnd()
4406 
    result = shiftToWarehouse_result()
4407 
    try:
4408 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4409 
    except TransactionServiceException, ex:
4410 
      result.ex = ex
4411 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4412 
    result.write(oprot)
4413 
    oprot.writeMessageEnd()
4414 
    oprot.trans.flush()
4415 
 
3553 chandransh 4416 
  def process_addDelayReason(self, seqid, iprot, oprot):
4417 
    args = addDelayReason_args()
4418 
    args.read(iprot)
4419 
    iprot.readMessageEnd()
4420 
    result = addDelayReason_result()
4421 
    try:
3986 chandransh 4422 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4423 
    except TransactionServiceException, ex:
4424 
      result.ex = ex
4425 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4426 
    result.write(oprot)
4427 
    oprot.writeMessageEnd()
4428 
    oprot.trans.flush()
3469 chandransh 4429 
 
3956 chandransh 4430 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4431 
    args = reconcileCodCollection_args()
4432 
    args.read(iprot)
4433 
    iprot.readMessageEnd()
4434 
    result = reconcileCodCollection_result()
4435 
    try:
4436 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4437 
    except TransactionServiceException, ex:
4438 
      result.ex = ex
4439 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4440 
    result.write(oprot)
4441 
    oprot.writeMessageEnd()
4442 
    oprot.trans.flush()
3553 chandransh 4443 
 
4008 mandeep.dh 4444 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4445 
    args = getTransactionsRequiringExtraProcessing_args()
4446 
    args.read(iprot)
4447 
    iprot.readMessageEnd()
4448 
    result = getTransactionsRequiringExtraProcessing_result()
4449 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4450 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
3956 chandransh 4454 
 
4008 mandeep.dh 4455 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4456 
    args = markTransactionAsProcessed_args()
4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
4459 
    result = markTransactionAsProcessed_result()
4460 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4461 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4462 
    result.write(oprot)
4463 
    oprot.writeMessageEnd()
4464 
    oprot.trans.flush()
4465 
 
4018 chandransh 4466 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4467 
    args = getItemWiseRiskyOrdersCount_args()
4468 
    args.read(iprot)
4469 
    iprot.readMessageEnd()
4470 
    result = getItemWiseRiskyOrdersCount_result()
4471 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4472 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4008 mandeep.dh 4476 
 
4295 varun.gupt 4477 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4478 
    args = getOrdersForItemIds_args()
4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
4481 
    result = getOrdersForItemIds_result()
4482 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4483 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4484 
    result.write(oprot)
4485 
    oprot.writeMessageEnd()
4486 
    oprot.trans.flush()
4487 
 
4247 rajveer 4488 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4489 
    args = markOrderCancellationRequestReceived_args()
4490 
    args.read(iprot)
4491 
    iprot.readMessageEnd()
4492 
    result = markOrderCancellationRequestReceived_result()
4493 
    try:
4494 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4495 
    except TransactionServiceException, ex:
4496 
      result.ex = ex
4497 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4498 
    result.write(oprot)
4499 
    oprot.writeMessageEnd()
4500 
    oprot.trans.flush()
4018 chandransh 4501 
 
4247 rajveer 4502 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4503 
    args = markOrderCancellationRequestConfirmed_args()
4504 
    args.read(iprot)
4505 
    iprot.readMessageEnd()
4506 
    result = markOrderCancellationRequestConfirmed_result()
4507 
    try:
4508 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4509 
    except TransactionServiceException, ex:
4510 
      result.ex = ex
4511 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4512 
    result.write(oprot)
4513 
    oprot.writeMessageEnd()
4514 
    oprot.trans.flush()
4515 
 
4516 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4517 
    args = markOrderCancellationRequestDenied_args()
4518 
    args.read(iprot)
4519 
    iprot.readMessageEnd()
4520 
    result = markOrderCancellationRequestDenied_result()
4521 
    try:
4522 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4523 
    except TransactionServiceException, ex:
4524 
      result.ex = ex
4525 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4526 
    result.write(oprot)
4527 
    oprot.writeMessageEnd()
4528 
    oprot.trans.flush()
4529 
 
4258 rajveer 4530 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4531 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4532 
    args.read(iprot)
4533 
    iprot.readMessageEnd()
4258 rajveer 4534 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4535 
    try:
4258 rajveer 4536 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4537 
    except TransactionServiceException, ex:
4538 
      result.ex = ex
4258 rajveer 4539 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4540 
    result.write(oprot)
4541 
    oprot.writeMessageEnd()
4542 
    oprot.trans.flush()
4543 
 
4259 anupam.sin 4544 
  def process_refundTransaction(self, seqid, iprot, oprot):
4545 
    args = refundTransaction_args()
4546 
    args.read(iprot)
4547 
    iprot.readMessageEnd()
4548 
    result = refundTransaction_result()
4549 
    try:
4550 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4551 
    except TransactionServiceException, ex:
4552 
      result.ex = ex
4553 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4554 
    result.write(oprot)
4555 
    oprot.writeMessageEnd()
4556 
    oprot.trans.flush()
4247 rajveer 4557 
 
4324 mandeep.dh 4558 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4559 
    args = updateShipmentAddress_args()
4560 
    args.read(iprot)
4561 
    iprot.readMessageEnd()
4562 
    result = updateShipmentAddress_result()
4563 
    try:
4564 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4565 
    except TransactionServiceException, ex:
4566 
      result.ex = ex
4567 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4568 
    result.write(oprot)
4569 
    oprot.writeMessageEnd()
4570 
    oprot.trans.flush()
4571 
 
4285 rajveer 4572 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4573 
    args = acceptOrdersForItemId_args()
4574 
    args.read(iprot)
4575 
    iprot.readMessageEnd()
4576 
    result = acceptOrdersForItemId_result()
4577 
    try:
4578 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4579 
    except TransactionServiceException, ex:
4580 
      result.ex = ex
4581 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4259 anupam.sin 4585 
 
4303 rajveer 4586 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4587 
    args = markOrdersAsPORaised_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = markOrdersAsPORaised_result()
4591 
    try:
4369 rajveer 4592 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4593 
    except TransactionServiceException, ex:
4594 
      result.ex = ex
4595 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
4285 rajveer 4599 
 
4303 rajveer 4600 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4601 
    args = markOrdersAsReversalInitiated_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = markOrdersAsReversalInitiated_result()
4605 
    try:
4369 rajveer 4606 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4607 
    except TransactionServiceException, ex:
4608 
      result.ex = ex
4609 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4610 
    result.write(oprot)
4611 
    oprot.writeMessageEnd()
4612 
    oprot.trans.flush()
4613 
 
4614 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4615 
    args = markOrdersAsNotAvailabke_args()
4616 
    args.read(iprot)
4617 
    iprot.readMessageEnd()
4618 
    result = markOrdersAsNotAvailabke_result()
4619 
    try:
4369 rajveer 4620 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4621 
    except TransactionServiceException, ex:
4622 
      result.ex = ex
4623 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4624 
    result.write(oprot)
4625 
    oprot.writeMessageEnd()
4626 
    oprot.trans.flush()
4627 
 
4369 rajveer 4628 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4629 
    args = markOrdersAsTimeout_args()
4630 
    args.read(iprot)
4631 
    iprot.readMessageEnd()
4632 
    result = markOrdersAsTimeout_result()
4633 
    try:
4634 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4635 
    except TransactionServiceException, ex:
4636 
      result.ex = ex
4637 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4638 
    result.write(oprot)
4639 
    oprot.writeMessageEnd()
4640 
    oprot.trans.flush()
4303 rajveer 4641 
 
4386 anupam.sin 4642 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4643 
    args = getOrderForAwb_args()
4644 
    args.read(iprot)
4645 
    iprot.readMessageEnd()
4646 
    result = getOrderForAwb_result()
4647 
    try:
4648 
      result.success = self._handler.getOrderForAwb(args.awb)
4649 
    except TransactionServiceException, ex:
4650 
      result.ex = ex
4651 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4652 
    result.write(oprot)
4653 
    oprot.writeMessageEnd()
4654 
    oprot.trans.flush()
4369 rajveer 4655 
 
4386 anupam.sin 4656 
 
94 ashish 4657 
# HELPER FUNCTIONS AND STRUCTURES
4658 
 
4659 
class createTransaction_args:
4660 
  """
4661 
  Attributes:
4662 
   - transaction
4663 
  """
4664 
 
4665 
  thrift_spec = (
4666 
    None, # 0
4667 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4668 
  )
4669 
 
4670 
  def __init__(self, transaction=None,):
4671 
    self.transaction = transaction
4672 
 
4673 
  def read(self, iprot):
4674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4676 
      return
4677 
    iprot.readStructBegin()
4678 
    while True:
4679 
      (fname, ftype, fid) = iprot.readFieldBegin()
4680 
      if ftype == TType.STOP:
4681 
        break
4682 
      if fid == 1:
4683 
        if ftype == TType.STRUCT:
4684 
          self.transaction = Transaction()
4685 
          self.transaction.read(iprot)
4686 
        else:
4687 
          iprot.skip(ftype)
4688 
      else:
4689 
        iprot.skip(ftype)
4690 
      iprot.readFieldEnd()
4691 
    iprot.readStructEnd()
4692 
 
4693 
  def write(self, oprot):
4694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4696 
      return
4697 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4698 
    if self.transaction is not None:
94 ashish 4699 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4700 
      self.transaction.write(oprot)
4701 
      oprot.writeFieldEnd()
4702 
    oprot.writeFieldStop()
4703 
    oprot.writeStructEnd()
4704 
 
3431 rajveer 4705 
  def validate(self):
4706 
    return
4707 
 
4708 
 
94 ashish 4709 
  def __repr__(self):
4710 
    L = ['%s=%r' % (key, value)
4711 
      for key, value in self.__dict__.iteritems()]
4712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4713 
 
4714 
  def __eq__(self, other):
4715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4716 
 
4717 
  def __ne__(self, other):
4718 
    return not (self == other)
4719 
 
4720 
class createTransaction_result:
4721 
  """
4722 
  Attributes:
132 ashish 4723 
   - success
94 ashish 4724 
   - ex
4725 
  """
4726 
 
4727 
  thrift_spec = (
132 ashish 4728 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4730 
  )
4731 
 
132 ashish 4732 
  def __init__(self, success=None, ex=None,):
4733 
    self.success = success
94 ashish 4734 
    self.ex = ex
4735 
 
4736 
  def read(self, iprot):
4737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4739 
      return
4740 
    iprot.readStructBegin()
4741 
    while True:
4742 
      (fname, ftype, fid) = iprot.readFieldBegin()
4743 
      if ftype == TType.STOP:
4744 
        break
132 ashish 4745 
      if fid == 0:
4746 
        if ftype == TType.I64:
4747 
          self.success = iprot.readI64();
4748 
        else:
4749 
          iprot.skip(ftype)
4750 
      elif fid == 1:
94 ashish 4751 
        if ftype == TType.STRUCT:
4752 
          self.ex = TransactionServiceException()
4753 
          self.ex.read(iprot)
4754 
        else:
4755 
          iprot.skip(ftype)
4756 
      else:
4757 
        iprot.skip(ftype)
4758 
      iprot.readFieldEnd()
4759 
    iprot.readStructEnd()
4760 
 
4761 
  def write(self, oprot):
4762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4764 
      return
4765 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4766 
    if self.success is not None:
132 ashish 4767 
      oprot.writeFieldBegin('success', TType.I64, 0)
4768 
      oprot.writeI64(self.success)
4769 
      oprot.writeFieldEnd()
3431 rajveer 4770 
    if self.ex is not None:
94 ashish 4771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4772 
      self.ex.write(oprot)
4773 
      oprot.writeFieldEnd()
4774 
    oprot.writeFieldStop()
4775 
    oprot.writeStructEnd()
4776 
 
3431 rajveer 4777 
  def validate(self):
4778 
    return
4779 
 
4780 
 
94 ashish 4781 
  def __repr__(self):
4782 
    L = ['%s=%r' % (key, value)
4783 
      for key, value in self.__dict__.iteritems()]
4784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4785 
 
4786 
  def __eq__(self, other):
4787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4788 
 
4789 
  def __ne__(self, other):
4790 
    return not (self == other)
4791 
 
4792 
class getTransaction_args:
4793 
  """
4794 
  Attributes:
4795 
   - id
4796 
  """
4797 
 
4798 
  thrift_spec = (
4799 
    None, # 0
4800 
    (1, TType.I64, 'id', None, None, ), # 1
4801 
  )
4802 
 
4803 
  def __init__(self, id=None,):
4804 
    self.id = id
4805 
 
4806 
  def read(self, iprot):
4807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4809 
      return
4810 
    iprot.readStructBegin()
4811 
    while True:
4812 
      (fname, ftype, fid) = iprot.readFieldBegin()
4813 
      if ftype == TType.STOP:
4814 
        break
4815 
      if fid == 1:
4816 
        if ftype == TType.I64:
4817 
          self.id = iprot.readI64();
4818 
        else:
4819 
          iprot.skip(ftype)
4820 
      else:
4821 
        iprot.skip(ftype)
4822 
      iprot.readFieldEnd()
4823 
    iprot.readStructEnd()
4824 
 
4825 
  def write(self, oprot):
4826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4828 
      return
4829 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4830 
    if self.id is not None:
94 ashish 4831 
      oprot.writeFieldBegin('id', TType.I64, 1)
4832 
      oprot.writeI64(self.id)
4833 
      oprot.writeFieldEnd()
4834 
    oprot.writeFieldStop()
4835 
    oprot.writeStructEnd()
4836 
 
3431 rajveer 4837 
  def validate(self):
4838 
    return
4839 
 
4840 
 
94 ashish 4841 
  def __repr__(self):
4842 
    L = ['%s=%r' % (key, value)
4843 
      for key, value in self.__dict__.iteritems()]
4844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4845 
 
4846 
  def __eq__(self, other):
4847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4848 
 
4849 
  def __ne__(self, other):
4850 
    return not (self == other)
4851 
 
4852 
class getTransaction_result:
4853 
  """
4854 
  Attributes:
4855 
   - success
4856 
   - ex
4857 
  """
4858 
 
4859 
  thrift_spec = (
4860 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4862 
  )
4863 
 
4864 
  def __init__(self, success=None, ex=None,):
4865 
    self.success = success
4866 
    self.ex = ex
4867 
 
4868 
  def read(self, iprot):
4869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4871 
      return
4872 
    iprot.readStructBegin()
4873 
    while True:
4874 
      (fname, ftype, fid) = iprot.readFieldBegin()
4875 
      if ftype == TType.STOP:
4876 
        break
4877 
      if fid == 0:
4878 
        if ftype == TType.STRUCT:
4879 
          self.success = Transaction()
4880 
          self.success.read(iprot)
4881 
        else:
4882 
          iprot.skip(ftype)
4883 
      elif fid == 1:
4884 
        if ftype == TType.STRUCT:
4885 
          self.ex = TransactionServiceException()
4886 
          self.ex.read(iprot)
4887 
        else:
4888 
          iprot.skip(ftype)
4889 
      else:
4890 
        iprot.skip(ftype)
4891 
      iprot.readFieldEnd()
4892 
    iprot.readStructEnd()
4893 
 
4894 
  def write(self, oprot):
4895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4897 
      return
4898 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4899 
    if self.success is not None:
94 ashish 4900 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4901 
      self.success.write(oprot)
4902 
      oprot.writeFieldEnd()
3431 rajveer 4903 
    if self.ex is not None:
94 ashish 4904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4905 
      self.ex.write(oprot)
4906 
      oprot.writeFieldEnd()
4907 
    oprot.writeFieldStop()
4908 
    oprot.writeStructEnd()
4909 
 
3431 rajveer 4910 
  def validate(self):
4911 
    return
4912 
 
4913 
 
94 ashish 4914 
  def __repr__(self):
4915 
    L = ['%s=%r' % (key, value)
4916 
      for key, value in self.__dict__.iteritems()]
4917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4918 
 
4919 
  def __eq__(self, other):
4920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4921 
 
4922 
  def __ne__(self, other):
4923 
    return not (self == other)
4924 
 
4925 
class getTransactionsForCustomer_args:
4926 
  """
4927 
  Attributes:
4928 
   - customerId
4929 
   - from_date
4930 
   - to_date
4931 
   - status
4932 
  """
4933 
 
4934 
  thrift_spec = (
4935 
    None, # 0
4936 
    (1, TType.I64, 'customerId', None, None, ), # 1
4937 
    (2, TType.I64, 'from_date', None, None, ), # 2
4938 
    (3, TType.I64, 'to_date', None, None, ), # 3
4939 
    (4, TType.I32, 'status', None, None, ), # 4
4940 
  )
4941 
 
4942 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4943 
    self.customerId = customerId
4944 
    self.from_date = from_date
4945 
    self.to_date = to_date
4946 
    self.status = status
4947 
 
4948 
  def read(self, iprot):
4949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4951 
      return
4952 
    iprot.readStructBegin()
4953 
    while True:
4954 
      (fname, ftype, fid) = iprot.readFieldBegin()
4955 
      if ftype == TType.STOP:
4956 
        break
4957 
      if fid == 1:
4958 
        if ftype == TType.I64:
4959 
          self.customerId = iprot.readI64();
4960 
        else:
4961 
          iprot.skip(ftype)
4962 
      elif fid == 2:
4963 
        if ftype == TType.I64:
4964 
          self.from_date = iprot.readI64();
4965 
        else:
4966 
          iprot.skip(ftype)
4967 
      elif fid == 3:
4968 
        if ftype == TType.I64:
4969 
          self.to_date = iprot.readI64();
4970 
        else:
4971 
          iprot.skip(ftype)
4972 
      elif fid == 4:
4973 
        if ftype == TType.I32:
4974 
          self.status = iprot.readI32();
4975 
        else:
4976 
          iprot.skip(ftype)
4977 
      else:
4978 
        iprot.skip(ftype)
4979 
      iprot.readFieldEnd()
4980 
    iprot.readStructEnd()
4981 
 
4982 
  def write(self, oprot):
4983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4985 
      return
4986 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4987 
    if self.customerId is not None:
94 ashish 4988 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4989 
      oprot.writeI64(self.customerId)
4990 
      oprot.writeFieldEnd()
3431 rajveer 4991 
    if self.from_date is not None:
94 ashish 4992 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4993 
      oprot.writeI64(self.from_date)
4994 
      oprot.writeFieldEnd()
3431 rajveer 4995 
    if self.to_date is not None:
94 ashish 4996 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4997 
      oprot.writeI64(self.to_date)
4998 
      oprot.writeFieldEnd()
3431 rajveer 4999 
    if self.status is not None:
94 ashish 5000 
      oprot.writeFieldBegin('status', TType.I32, 4)
5001 
      oprot.writeI32(self.status)
5002 
      oprot.writeFieldEnd()
5003 
    oprot.writeFieldStop()
5004 
    oprot.writeStructEnd()
5005 
 
3431 rajveer 5006 
  def validate(self):
5007 
    return
5008 
 
5009 
 
94 ashish 5010 
  def __repr__(self):
5011 
    L = ['%s=%r' % (key, value)
5012 
      for key, value in self.__dict__.iteritems()]
5013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5014 
 
5015 
  def __eq__(self, other):
5016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5017 
 
5018 
  def __ne__(self, other):
5019 
    return not (self == other)
5020 
 
5021 
class getTransactionsForCustomer_result:
5022 
  """
5023 
  Attributes:
5024 
   - success
5025 
   - ex
5026 
  """
5027 
 
5028 
  thrift_spec = (
5029 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5031 
  )
5032 
 
5033 
  def __init__(self, success=None, ex=None,):
5034 
    self.success = success
5035 
    self.ex = ex
5036 
 
5037 
  def read(self, iprot):
5038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5040 
      return
5041 
    iprot.readStructBegin()
5042 
    while True:
5043 
      (fname, ftype, fid) = iprot.readFieldBegin()
5044 
      if ftype == TType.STOP:
5045 
        break
5046 
      if fid == 0:
5047 
        if ftype == TType.LIST:
5048 
          self.success = []
685 chandransh 5049 
          (_etype17, _size14) = iprot.readListBegin()
5050 
          for _i18 in xrange(_size14):
5051 
            _elem19 = Transaction()
5052 
            _elem19.read(iprot)
5053 
            self.success.append(_elem19)
94 ashish 5054 
          iprot.readListEnd()
5055 
        else:
5056 
          iprot.skip(ftype)
5057 
      elif fid == 1:
5058 
        if ftype == TType.STRUCT:
5059 
          self.ex = TransactionServiceException()
5060 
          self.ex.read(iprot)
5061 
        else:
5062 
          iprot.skip(ftype)
5063 
      else:
5064 
        iprot.skip(ftype)
5065 
      iprot.readFieldEnd()
5066 
    iprot.readStructEnd()
5067 
 
5068 
  def write(self, oprot):
5069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5071 
      return
5072 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5073 
    if self.success is not None:
94 ashish 5074 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5075 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5076 
      for iter20 in self.success:
5077 
        iter20.write(oprot)
94 ashish 5078 
      oprot.writeListEnd()
5079 
      oprot.writeFieldEnd()
3431 rajveer 5080 
    if self.ex is not None:
94 ashish 5081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5082 
      self.ex.write(oprot)
5083 
      oprot.writeFieldEnd()
5084 
    oprot.writeFieldStop()
5085 
    oprot.writeStructEnd()
5086 
 
3431 rajveer 5087 
  def validate(self):
5088 
    return
5089 
 
5090 
 
94 ashish 5091 
  def __repr__(self):
5092 
    L = ['%s=%r' % (key, value)
5093 
      for key, value in self.__dict__.iteritems()]
5094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5095 
 
5096 
  def __eq__(self, other):
5097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5098 
 
5099 
  def __ne__(self, other):
5100 
    return not (self == other)
5101 
 
132 ashish 5102 
class getTransactionsForShoppingCartId_args:
5103 
  """
5104 
  Attributes:
5105 
   - shoppingCartId
5106 
  """
5107 
 
5108 
  thrift_spec = (
5109 
    None, # 0
5110 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5111 
  )
5112 
 
5113 
  def __init__(self, shoppingCartId=None,):
5114 
    self.shoppingCartId = shoppingCartId
5115 
 
5116 
  def read(self, iprot):
5117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5119 
      return
5120 
    iprot.readStructBegin()
5121 
    while True:
5122 
      (fname, ftype, fid) = iprot.readFieldBegin()
5123 
      if ftype == TType.STOP:
5124 
        break
5125 
      if fid == 1:
5126 
        if ftype == TType.I64:
5127 
          self.shoppingCartId = iprot.readI64();
5128 
        else:
5129 
          iprot.skip(ftype)
5130 
      else:
5131 
        iprot.skip(ftype)
5132 
      iprot.readFieldEnd()
5133 
    iprot.readStructEnd()
5134 
 
5135 
  def write(self, oprot):
5136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5138 
      return
5139 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5140 
    if self.shoppingCartId is not None:
132 ashish 5141 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5142 
      oprot.writeI64(self.shoppingCartId)
5143 
      oprot.writeFieldEnd()
5144 
    oprot.writeFieldStop()
5145 
    oprot.writeStructEnd()
5146 
 
3431 rajveer 5147 
  def validate(self):
5148 
    return
5149 
 
5150 
 
132 ashish 5151 
  def __repr__(self):
5152 
    L = ['%s=%r' % (key, value)
5153 
      for key, value in self.__dict__.iteritems()]
5154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5155 
 
5156 
  def __eq__(self, other):
5157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5158 
 
5159 
  def __ne__(self, other):
5160 
    return not (self == other)
5161 
 
5162 
class getTransactionsForShoppingCartId_result:
5163 
  """
5164 
  Attributes:
5165 
   - success
5166 
   - ex
5167 
  """
5168 
 
5169 
  thrift_spec = (
5170 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5172 
  )
5173 
 
5174 
  def __init__(self, success=None, ex=None,):
5175 
    self.success = success
5176 
    self.ex = ex
5177 
 
5178 
  def read(self, iprot):
5179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5181 
      return
5182 
    iprot.readStructBegin()
5183 
    while True:
5184 
      (fname, ftype, fid) = iprot.readFieldBegin()
5185 
      if ftype == TType.STOP:
5186 
        break
5187 
      if fid == 0:
5188 
        if ftype == TType.LIST:
5189 
          self.success = []
685 chandransh 5190 
          (_etype24, _size21) = iprot.readListBegin()
5191 
          for _i25 in xrange(_size21):
5192 
            _elem26 = Transaction()
5193 
            _elem26.read(iprot)
5194 
            self.success.append(_elem26)
132 ashish 5195 
          iprot.readListEnd()
5196 
        else:
5197 
          iprot.skip(ftype)
5198 
      elif fid == 1:
5199 
        if ftype == TType.STRUCT:
5200 
          self.ex = TransactionServiceException()
5201 
          self.ex.read(iprot)
5202 
        else:
5203 
          iprot.skip(ftype)
5204 
      else:
5205 
        iprot.skip(ftype)
5206 
      iprot.readFieldEnd()
5207 
    iprot.readStructEnd()
5208 
 
5209 
  def write(self, oprot):
5210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5212 
      return
5213 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5214 
    if self.success is not None:
132 ashish 5215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5217 
      for iter27 in self.success:
5218 
        iter27.write(oprot)
132 ashish 5219 
      oprot.writeListEnd()
5220 
      oprot.writeFieldEnd()
3431 rajveer 5221 
    if self.ex is not None:
132 ashish 5222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5223 
      self.ex.write(oprot)
5224 
      oprot.writeFieldEnd()
5225 
    oprot.writeFieldStop()
5226 
    oprot.writeStructEnd()
5227 
 
3431 rajveer 5228 
  def validate(self):
5229 
    return
5230 
 
5231 
 
132 ashish 5232 
  def __repr__(self):
5233 
    L = ['%s=%r' % (key, value)
5234 
      for key, value in self.__dict__.iteritems()]
5235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5236 
 
5237 
  def __eq__(self, other):
5238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5239 
 
5240 
  def __ne__(self, other):
5241 
    return not (self == other)
5242 
 
94 ashish 5243 
class getTransactionStatus_args:
5244 
  """
5245 
  Attributes:
5246 
   - transactionId
5247 
  """
5248 
 
5249 
  thrift_spec = (
5250 
    None, # 0
5251 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5252 
  )
5253 
 
5254 
  def __init__(self, transactionId=None,):
5255 
    self.transactionId = transactionId
5256 
 
5257 
  def read(self, iprot):
5258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5260 
      return
5261 
    iprot.readStructBegin()
5262 
    while True:
5263 
      (fname, ftype, fid) = iprot.readFieldBegin()
5264 
      if ftype == TType.STOP:
5265 
        break
5266 
      if fid == 1:
5267 
        if ftype == TType.I64:
5268 
          self.transactionId = iprot.readI64();
5269 
        else:
5270 
          iprot.skip(ftype)
5271 
      else:
5272 
        iprot.skip(ftype)
5273 
      iprot.readFieldEnd()
5274 
    iprot.readStructEnd()
5275 
 
5276 
  def write(self, oprot):
5277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5279 
      return
5280 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5281 
    if self.transactionId is not None:
94 ashish 5282 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5283 
      oprot.writeI64(self.transactionId)
5284 
      oprot.writeFieldEnd()
5285 
    oprot.writeFieldStop()
5286 
    oprot.writeStructEnd()
5287 
 
3431 rajveer 5288 
  def validate(self):
5289 
    return
5290 
 
5291 
 
94 ashish 5292 
  def __repr__(self):
5293 
    L = ['%s=%r' % (key, value)
5294 
      for key, value in self.__dict__.iteritems()]
5295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5296 
 
5297 
  def __eq__(self, other):
5298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5299 
 
5300 
  def __ne__(self, other):
5301 
    return not (self == other)
5302 
 
5303 
class getTransactionStatus_result:
5304 
  """
5305 
  Attributes:
5306 
   - success
5307 
   - ex
5308 
  """
5309 
 
5310 
  thrift_spec = (
5311 
    (0, TType.I32, 'success', None, None, ), # 0
5312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5313 
  )
5314 
 
5315 
  def __init__(self, success=None, ex=None,):
5316 
    self.success = success
5317 
    self.ex = ex
5318 
 
5319 
  def read(self, iprot):
5320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5322 
      return
5323 
    iprot.readStructBegin()
5324 
    while True:
5325 
      (fname, ftype, fid) = iprot.readFieldBegin()
5326 
      if ftype == TType.STOP:
5327 
        break
5328 
      if fid == 0:
5329 
        if ftype == TType.I32:
5330 
          self.success = iprot.readI32();
5331 
        else:
5332 
          iprot.skip(ftype)
5333 
      elif fid == 1:
5334 
        if ftype == TType.STRUCT:
5335 
          self.ex = TransactionServiceException()
5336 
          self.ex.read(iprot)
5337 
        else:
5338 
          iprot.skip(ftype)
5339 
      else:
5340 
        iprot.skip(ftype)
5341 
      iprot.readFieldEnd()
5342 
    iprot.readStructEnd()
5343 
 
5344 
  def write(self, oprot):
5345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5347 
      return
5348 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5349 
    if self.success is not None:
94 ashish 5350 
      oprot.writeFieldBegin('success', TType.I32, 0)
5351 
      oprot.writeI32(self.success)
5352 
      oprot.writeFieldEnd()
3431 rajveer 5353 
    if self.ex is not None:
94 ashish 5354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5355 
      self.ex.write(oprot)
5356 
      oprot.writeFieldEnd()
5357 
    oprot.writeFieldStop()
5358 
    oprot.writeStructEnd()
5359 
 
3431 rajveer 5360 
  def validate(self):
5361 
    return
5362 
 
5363 
 
94 ashish 5364 
  def __repr__(self):
5365 
    L = ['%s=%r' % (key, value)
5366 
      for key, value in self.__dict__.iteritems()]
5367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5368 
 
5369 
  def __eq__(self, other):
5370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5371 
 
5372 
  def __ne__(self, other):
5373 
    return not (self == other)
5374 
 
5375 
class changeTransactionStatus_args:
5376 
  """
5377 
  Attributes:
5378 
   - transactionId
5379 
   - status
5380 
   - description
5381 
  """
5382 
 
5383 
  thrift_spec = (
5384 
    None, # 0
5385 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5386 
    (2, TType.I32, 'status', None, None, ), # 2
5387 
    (3, TType.STRING, 'description', None, None, ), # 3
5388 
  )
5389 
 
5390 
  def __init__(self, transactionId=None, status=None, description=None,):
5391 
    self.transactionId = transactionId
5392 
    self.status = status
5393 
    self.description = description
5394 
 
5395 
  def read(self, iprot):
5396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5398 
      return
5399 
    iprot.readStructBegin()
5400 
    while True:
5401 
      (fname, ftype, fid) = iprot.readFieldBegin()
5402 
      if ftype == TType.STOP:
5403 
        break
5404 
      if fid == 1:
5405 
        if ftype == TType.I64:
5406 
          self.transactionId = iprot.readI64();
5407 
        else:
5408 
          iprot.skip(ftype)
5409 
      elif fid == 2:
5410 
        if ftype == TType.I32:
5411 
          self.status = iprot.readI32();
5412 
        else:
5413 
          iprot.skip(ftype)
5414 
      elif fid == 3:
5415 
        if ftype == TType.STRING:
5416 
          self.description = iprot.readString();
5417 
        else:
5418 
          iprot.skip(ftype)
5419 
      else:
5420 
        iprot.skip(ftype)
5421 
      iprot.readFieldEnd()
5422 
    iprot.readStructEnd()
5423 
 
5424 
  def write(self, oprot):
5425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5427 
      return
5428 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5429 
    if self.transactionId is not None:
94 ashish 5430 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5431 
      oprot.writeI64(self.transactionId)
5432 
      oprot.writeFieldEnd()
3431 rajveer 5433 
    if self.status is not None:
94 ashish 5434 
      oprot.writeFieldBegin('status', TType.I32, 2)
5435 
      oprot.writeI32(self.status)
5436 
      oprot.writeFieldEnd()
3431 rajveer 5437 
    if self.description is not None:
94 ashish 5438 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5439 
      oprot.writeString(self.description)
5440 
      oprot.writeFieldEnd()
5441 
    oprot.writeFieldStop()
5442 
    oprot.writeStructEnd()
5443 
 
3431 rajveer 5444 
  def validate(self):
5445 
    return
5446 
 
5447 
 
94 ashish 5448 
  def __repr__(self):
5449 
    L = ['%s=%r' % (key, value)
5450 
      for key, value in self.__dict__.iteritems()]
5451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5452 
 
5453 
  def __eq__(self, other):
5454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5455 
 
5456 
  def __ne__(self, other):
5457 
    return not (self == other)
5458 
 
5459 
class changeTransactionStatus_result:
5460 
  """
5461 
  Attributes:
5462 
   - success
5463 
   - ex
5464 
  """
5465 
 
5466 
  thrift_spec = (
5467 
    (0, TType.BOOL, 'success', None, None, ), # 0
5468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5469 
  )
5470 
 
5471 
  def __init__(self, success=None, ex=None,):
5472 
    self.success = success
5473 
    self.ex = ex
5474 
 
5475 
  def read(self, iprot):
5476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5478 
      return
5479 
    iprot.readStructBegin()
5480 
    while True:
5481 
      (fname, ftype, fid) = iprot.readFieldBegin()
5482 
      if ftype == TType.STOP:
5483 
        break
5484 
      if fid == 0:
5485 
        if ftype == TType.BOOL:
5486 
          self.success = iprot.readBool();
5487 
        else:
5488 
          iprot.skip(ftype)
5489 
      elif fid == 1:
5490 
        if ftype == TType.STRUCT:
5491 
          self.ex = TransactionServiceException()
5492 
          self.ex.read(iprot)
5493 
        else:
5494 
          iprot.skip(ftype)
5495 
      else:
5496 
        iprot.skip(ftype)
5497 
      iprot.readFieldEnd()
5498 
    iprot.readStructEnd()
5499 
 
5500 
  def write(self, oprot):
5501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5503 
      return
5504 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5505 
    if self.success is not None:
94 ashish 5506 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5507 
      oprot.writeBool(self.success)
5508 
      oprot.writeFieldEnd()
3431 rajveer 5509 
    if self.ex is not None:
94 ashish 5510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5511 
      self.ex.write(oprot)
5512 
      oprot.writeFieldEnd()
5513 
    oprot.writeFieldStop()
5514 
    oprot.writeStructEnd()
5515 
 
3431 rajveer 5516 
  def validate(self):
5517 
    return
5518 
 
5519 
 
94 ashish 5520 
  def __repr__(self):
5521 
    L = ['%s=%r' % (key, value)
5522 
      for key, value in self.__dict__.iteritems()]
5523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5524 
 
5525 
  def __eq__(self, other):
5526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5527 
 
5528 
  def __ne__(self, other):
5529 
    return not (self == other)
5530 
 
1398 varun.gupt 5531 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5532 
  """
5533 
  Attributes:
5534 
   - transactionId
5535 
  """
5536 
 
5537 
  thrift_spec = (
5538 
    None, # 0
5539 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5540 
  )
5541 
 
5542 
  def __init__(self, transactionId=None,):
5543 
    self.transactionId = transactionId
5544 
 
5545 
  def read(self, iprot):
5546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5548 
      return
5549 
    iprot.readStructBegin()
5550 
    while True:
5551 
      (fname, ftype, fid) = iprot.readFieldBegin()
5552 
      if ftype == TType.STOP:
5553 
        break
5554 
      if fid == 1:
5555 
        if ftype == TType.I64:
5556 
          self.transactionId = iprot.readI64();
5557 
        else:
5558 
          iprot.skip(ftype)
5559 
      else:
5560 
        iprot.skip(ftype)
5561 
      iprot.readFieldEnd()
5562 
    iprot.readStructEnd()
5563 
 
5564 
  def write(self, oprot):
5565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5567 
      return
1398 varun.gupt 5568 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5569 
    if self.transactionId is not None:
1382 varun.gupt 5570 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5571 
      oprot.writeI64(self.transactionId)
5572 
      oprot.writeFieldEnd()
5573 
    oprot.writeFieldStop()
5574 
    oprot.writeStructEnd()
5575 
 
3431 rajveer 5576 
  def validate(self):
5577 
    return
5578 
 
5579 
 
1382 varun.gupt 5580 
  def __repr__(self):
5581 
    L = ['%s=%r' % (key, value)
5582 
      for key, value in self.__dict__.iteritems()]
5583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5584 
 
5585 
  def __eq__(self, other):
5586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5587 
 
5588 
  def __ne__(self, other):
5589 
    return not (self == other)
5590 
 
1398 varun.gupt 5591 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5592 
  """
5593 
  Attributes:
5594 
   - success
5595 
   - ex
5596 
  """
5597 
 
5598 
  thrift_spec = (
5599 
    (0, TType.BOOL, 'success', None, None, ), # 0
5600 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5601 
  )
5602 
 
5603 
  def __init__(self, success=None, ex=None,):
5604 
    self.success = success
5605 
    self.ex = ex
5606 
 
5607 
  def read(self, iprot):
5608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5610 
      return
5611 
    iprot.readStructBegin()
5612 
    while True:
5613 
      (fname, ftype, fid) = iprot.readFieldBegin()
5614 
      if ftype == TType.STOP:
5615 
        break
5616 
      if fid == 0:
5617 
        if ftype == TType.BOOL:
5618 
          self.success = iprot.readBool();
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      elif fid == 1:
5622 
        if ftype == TType.STRUCT:
5623 
          self.ex = TransactionServiceException()
5624 
          self.ex.read(iprot)
5625 
        else:
5626 
          iprot.skip(ftype)
5627 
      else:
5628 
        iprot.skip(ftype)
5629 
      iprot.readFieldEnd()
5630 
    iprot.readStructEnd()
5631 
 
5632 
  def write(self, oprot):
5633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5635 
      return
1398 varun.gupt 5636 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5637 
    if self.success is not None:
1382 varun.gupt 5638 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5639 
      oprot.writeBool(self.success)
5640 
      oprot.writeFieldEnd()
3431 rajveer 5641 
    if self.ex is not None:
1382 varun.gupt 5642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5643 
      self.ex.write(oprot)
5644 
      oprot.writeFieldEnd()
5645 
    oprot.writeFieldStop()
5646 
    oprot.writeStructEnd()
5647 
 
3431 rajveer 5648 
  def validate(self):
5649 
    return
5650 
 
5651 
 
1382 varun.gupt 5652 
  def __repr__(self):
5653 
    L = ['%s=%r' % (key, value)
5654 
      for key, value in self.__dict__.iteritems()]
5655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5656 
 
5657 
  def __eq__(self, other):
5658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5659 
 
5660 
  def __ne__(self, other):
5661 
    return not (self == other)
5662 
 
483 rajveer 5663 
class getAllOrders_args:
94 ashish 5664 
  """
5665 
  Attributes:
483 rajveer 5666 
   - status
5667 
   - from_date
5668 
   - to_date
5669 
   - warehouse_id
94 ashish 5670 
  """
5671 
 
5672 
  thrift_spec = (
5673 
    None, # 0
483 rajveer 5674 
    (1, TType.I32, 'status', None, None, ), # 1
5675 
    (2, TType.I64, 'from_date', None, None, ), # 2
5676 
    (3, TType.I64, 'to_date', None, None, ), # 3
5677 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5678 
  )
5679 
 
483 rajveer 5680 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5681 
    self.status = status
5682 
    self.from_date = from_date
5683 
    self.to_date = to_date
5684 
    self.warehouse_id = warehouse_id
94 ashish 5685 
 
5686 
  def read(self, iprot):
5687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5689 
      return
5690 
    iprot.readStructBegin()
5691 
    while True:
5692 
      (fname, ftype, fid) = iprot.readFieldBegin()
5693 
      if ftype == TType.STOP:
5694 
        break
5695 
      if fid == 1:
483 rajveer 5696 
        if ftype == TType.I32:
5697 
          self.status = iprot.readI32();
94 ashish 5698 
        else:
5699 
          iprot.skip(ftype)
483 rajveer 5700 
      elif fid == 2:
5701 
        if ftype == TType.I64:
5702 
          self.from_date = iprot.readI64();
94 ashish 5703 
        else:
5704 
          iprot.skip(ftype)
483 rajveer 5705 
      elif fid == 3:
5706 
        if ftype == TType.I64:
5707 
          self.to_date = iprot.readI64();
94 ashish 5708 
        else:
5709 
          iprot.skip(ftype)
483 rajveer 5710 
      elif fid == 4:
94 ashish 5711 
        if ftype == TType.I64:
483 rajveer 5712 
          self.warehouse_id = iprot.readI64();
94 ashish 5713 
        else:
5714 
          iprot.skip(ftype)
5715 
      else:
5716 
        iprot.skip(ftype)
5717 
      iprot.readFieldEnd()
5718 
    iprot.readStructEnd()
5719 
 
5720 
  def write(self, oprot):
5721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5723 
      return
483 rajveer 5724 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5725 
    if self.status is not None:
483 rajveer 5726 
      oprot.writeFieldBegin('status', TType.I32, 1)
5727 
      oprot.writeI32(self.status)
94 ashish 5728 
      oprot.writeFieldEnd()
3431 rajveer 5729 
    if self.from_date is not None:
483 rajveer 5730 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5731 
      oprot.writeI64(self.from_date)
94 ashish 5732 
      oprot.writeFieldEnd()
3431 rajveer 5733 
    if self.to_date is not None:
483 rajveer 5734 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5735 
      oprot.writeI64(self.to_date)
94 ashish 5736 
      oprot.writeFieldEnd()
3431 rajveer 5737 
    if self.warehouse_id is not None:
483 rajveer 5738 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5739 
      oprot.writeI64(self.warehouse_id)
94 ashish 5740 
      oprot.writeFieldEnd()
5741 
    oprot.writeFieldStop()
5742 
    oprot.writeStructEnd()
5743 
 
3431 rajveer 5744 
  def validate(self):
5745 
    return
5746 
 
5747 
 
94 ashish 5748 
  def __repr__(self):
5749 
    L = ['%s=%r' % (key, value)
5750 
      for key, value in self.__dict__.iteritems()]
5751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5752 
 
5753 
  def __eq__(self, other):
5754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5755 
 
5756 
  def __ne__(self, other):
5757 
    return not (self == other)
5758 
 
483 rajveer 5759 
class getAllOrders_result:
94 ashish 5760 
  """
5761 
  Attributes:
5762 
   - success
5763 
   - ex
5764 
  """
5765 
 
5766 
  thrift_spec = (
483 rajveer 5767 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5768 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5769 
  )
5770 
 
5771 
  def __init__(self, success=None, ex=None,):
5772 
    self.success = success
5773 
    self.ex = ex
5774 
 
5775 
  def read(self, iprot):
5776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5778 
      return
5779 
    iprot.readStructBegin()
5780 
    while True:
5781 
      (fname, ftype, fid) = iprot.readFieldBegin()
5782 
      if ftype == TType.STOP:
5783 
        break
5784 
      if fid == 0:
483 rajveer 5785 
        if ftype == TType.LIST:
5786 
          self.success = []
685 chandransh 5787 
          (_etype31, _size28) = iprot.readListBegin()
5788 
          for _i32 in xrange(_size28):
5789 
            _elem33 = Order()
5790 
            _elem33.read(iprot)
5791 
            self.success.append(_elem33)
483 rajveer 5792 
          iprot.readListEnd()
94 ashish 5793 
        else:
5794 
          iprot.skip(ftype)
5795 
      elif fid == 1:
5796 
        if ftype == TType.STRUCT:
5797 
          self.ex = TransactionServiceException()
5798 
          self.ex.read(iprot)
5799 
        else:
5800 
          iprot.skip(ftype)
5801 
      else:
5802 
        iprot.skip(ftype)
5803 
      iprot.readFieldEnd()
5804 
    iprot.readStructEnd()
5805 
 
5806 
  def write(self, oprot):
5807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5809 
      return
483 rajveer 5810 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5811 
    if self.success is not None:
483 rajveer 5812 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5813 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5814 
      for iter34 in self.success:
5815 
        iter34.write(oprot)
483 rajveer 5816 
      oprot.writeListEnd()
94 ashish 5817 
      oprot.writeFieldEnd()
3431 rajveer 5818 
    if self.ex is not None:
94 ashish 5819 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5820 
      self.ex.write(oprot)
5821 
      oprot.writeFieldEnd()
5822 
    oprot.writeFieldStop()
5823 
    oprot.writeStructEnd()
5824 
 
3431 rajveer 5825 
  def validate(self):
5826 
    return
5827 
 
5828 
 
94 ashish 5829 
  def __repr__(self):
5830 
    L = ['%s=%r' % (key, value)
5831 
      for key, value in self.__dict__.iteritems()]
5832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5833 
 
5834 
  def __eq__(self, other):
5835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5836 
 
5837 
  def __ne__(self, other):
5838 
    return not (self == other)
5839 
 
4133 chandransh 5840 
class getOrdersInBatch_args:
5841 
  """
5842 
  Attributes:
5843 
   - statuses
5844 
   - offset
5845 
   - limit
5846 
   - warehouse_id
5847 
  """
5848 
 
5849 
  thrift_spec = (
5850 
    None, # 0
5851 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5852 
    (2, TType.I64, 'offset', None, None, ), # 2
5853 
    (3, TType.I64, 'limit', None, None, ), # 3
5854 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5855 
  )
5856 
 
5857 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5858 
    self.statuses = statuses
5859 
    self.offset = offset
5860 
    self.limit = limit
5861 
    self.warehouse_id = warehouse_id
5862 
 
5863 
  def read(self, iprot):
5864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5866 
      return
5867 
    iprot.readStructBegin()
5868 
    while True:
5869 
      (fname, ftype, fid) = iprot.readFieldBegin()
5870 
      if ftype == TType.STOP:
5871 
        break
5872 
      if fid == 1:
5873 
        if ftype == TType.LIST:
5874 
          self.statuses = []
5875 
          (_etype38, _size35) = iprot.readListBegin()
5876 
          for _i39 in xrange(_size35):
5877 
            _elem40 = iprot.readI32();
5878 
            self.statuses.append(_elem40)
5879 
          iprot.readListEnd()
5880 
        else:
5881 
          iprot.skip(ftype)
5882 
      elif fid == 2:
5883 
        if ftype == TType.I64:
5884 
          self.offset = iprot.readI64();
5885 
        else:
5886 
          iprot.skip(ftype)
5887 
      elif fid == 3:
5888 
        if ftype == TType.I64:
5889 
          self.limit = iprot.readI64();
5890 
        else:
5891 
          iprot.skip(ftype)
5892 
      elif fid == 4:
5893 
        if ftype == TType.I64:
5894 
          self.warehouse_id = iprot.readI64();
5895 
        else:
5896 
          iprot.skip(ftype)
5897 
      else:
5898 
        iprot.skip(ftype)
5899 
      iprot.readFieldEnd()
5900 
    iprot.readStructEnd()
5901 
 
5902 
  def write(self, oprot):
5903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5905 
      return
5906 
    oprot.writeStructBegin('getOrdersInBatch_args')
5907 
    if self.statuses is not None:
5908 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5909 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5910 
      for iter41 in self.statuses:
5911 
        oprot.writeI32(iter41)
5912 
      oprot.writeListEnd()
5913 
      oprot.writeFieldEnd()
5914 
    if self.offset is not None:
5915 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5916 
      oprot.writeI64(self.offset)
5917 
      oprot.writeFieldEnd()
5918 
    if self.limit is not None:
5919 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5920 
      oprot.writeI64(self.limit)
5921 
      oprot.writeFieldEnd()
5922 
    if self.warehouse_id is not None:
5923 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5924 
      oprot.writeI64(self.warehouse_id)
5925 
      oprot.writeFieldEnd()
5926 
    oprot.writeFieldStop()
5927 
    oprot.writeStructEnd()
5928 
 
5929 
  def validate(self):
5930 
    return
5931 
 
5932 
 
5933 
  def __repr__(self):
5934 
    L = ['%s=%r' % (key, value)
5935 
      for key, value in self.__dict__.iteritems()]
5936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5937 
 
5938 
  def __eq__(self, other):
5939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5940 
 
5941 
  def __ne__(self, other):
5942 
    return not (self == other)
5943 
 
5944 
class getOrdersInBatch_result:
5945 
  """
5946 
  Attributes:
5947 
   - success
5948 
   - ex
5949 
  """
5950 
 
5951 
  thrift_spec = (
5952 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5954 
  )
5955 
 
5956 
  def __init__(self, success=None, ex=None,):
5957 
    self.success = success
5958 
    self.ex = ex
5959 
 
5960 
  def read(self, iprot):
5961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5963 
      return
5964 
    iprot.readStructBegin()
5965 
    while True:
5966 
      (fname, ftype, fid) = iprot.readFieldBegin()
5967 
      if ftype == TType.STOP:
5968 
        break
5969 
      if fid == 0:
5970 
        if ftype == TType.LIST:
5971 
          self.success = []
5972 
          (_etype45, _size42) = iprot.readListBegin()
5973 
          for _i46 in xrange(_size42):
5974 
            _elem47 = Order()
5975 
            _elem47.read(iprot)
5976 
            self.success.append(_elem47)
5977 
          iprot.readListEnd()
5978 
        else:
5979 
          iprot.skip(ftype)
5980 
      elif fid == 1:
5981 
        if ftype == TType.STRUCT:
5982 
          self.ex = TransactionServiceException()
5983 
          self.ex.read(iprot)
5984 
        else:
5985 
          iprot.skip(ftype)
5986 
      else:
5987 
        iprot.skip(ftype)
5988 
      iprot.readFieldEnd()
5989 
    iprot.readStructEnd()
5990 
 
5991 
  def write(self, oprot):
5992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5994 
      return
5995 
    oprot.writeStructBegin('getOrdersInBatch_result')
5996 
    if self.success is not None:
5997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5998 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5999 
      for iter48 in self.success:
6000 
        iter48.write(oprot)
6001 
      oprot.writeListEnd()
6002 
      oprot.writeFieldEnd()
6003 
    if self.ex is not None:
6004 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6005 
      self.ex.write(oprot)
6006 
      oprot.writeFieldEnd()
6007 
    oprot.writeFieldStop()
6008 
    oprot.writeStructEnd()
6009 
 
6010 
  def validate(self):
6011 
    return
6012 
 
6013 
 
6014 
  def __repr__(self):
6015 
    L = ['%s=%r' % (key, value)
6016 
      for key, value in self.__dict__.iteritems()]
6017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6018 
 
6019 
  def __eq__(self, other):
6020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6021 
 
6022 
  def __ne__(self, other):
6023 
    return not (self == other)
6024 
 
6025 
class getOrderCount_args:
6026 
  """
6027 
  Attributes:
6028 
   - statuses
6029 
   - warehouseId
6030 
  """
6031 
 
6032 
  thrift_spec = (
6033 
    None, # 0
6034 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6035 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6036 
  )
6037 
 
6038 
  def __init__(self, statuses=None, warehouseId=None,):
6039 
    self.statuses = statuses
6040 
    self.warehouseId = warehouseId
6041 
 
6042 
  def read(self, iprot):
6043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6045 
      return
6046 
    iprot.readStructBegin()
6047 
    while True:
6048 
      (fname, ftype, fid) = iprot.readFieldBegin()
6049 
      if ftype == TType.STOP:
6050 
        break
6051 
      if fid == 1:
6052 
        if ftype == TType.LIST:
6053 
          self.statuses = []
6054 
          (_etype52, _size49) = iprot.readListBegin()
6055 
          for _i53 in xrange(_size49):
6056 
            _elem54 = iprot.readI32();
6057 
            self.statuses.append(_elem54)
6058 
          iprot.readListEnd()
6059 
        else:
6060 
          iprot.skip(ftype)
6061 
      elif fid == 2:
6062 
        if ftype == TType.I64:
6063 
          self.warehouseId = iprot.readI64();
6064 
        else:
6065 
          iprot.skip(ftype)
6066 
      else:
6067 
        iprot.skip(ftype)
6068 
      iprot.readFieldEnd()
6069 
    iprot.readStructEnd()
6070 
 
6071 
  def write(self, oprot):
6072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6074 
      return
6075 
    oprot.writeStructBegin('getOrderCount_args')
6076 
    if self.statuses is not None:
6077 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6078 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6079 
      for iter55 in self.statuses:
6080 
        oprot.writeI32(iter55)
6081 
      oprot.writeListEnd()
6082 
      oprot.writeFieldEnd()
6083 
    if self.warehouseId is not None:
6084 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6085 
      oprot.writeI64(self.warehouseId)
6086 
      oprot.writeFieldEnd()
6087 
    oprot.writeFieldStop()
6088 
    oprot.writeStructEnd()
6089 
 
6090 
  def validate(self):
6091 
    return
6092 
 
6093 
 
6094 
  def __repr__(self):
6095 
    L = ['%s=%r' % (key, value)
6096 
      for key, value in self.__dict__.iteritems()]
6097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6098 
 
6099 
  def __eq__(self, other):
6100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6101 
 
6102 
  def __ne__(self, other):
6103 
    return not (self == other)
6104 
 
6105 
class getOrderCount_result:
6106 
  """
6107 
  Attributes:
6108 
   - success
6109 
   - ex
6110 
  """
6111 
 
6112 
  thrift_spec = (
6113 
    (0, TType.I32, 'success', None, None, ), # 0
6114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6115 
  )
6116 
 
6117 
  def __init__(self, success=None, ex=None,):
6118 
    self.success = success
6119 
    self.ex = ex
6120 
 
6121 
  def read(self, iprot):
6122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6124 
      return
6125 
    iprot.readStructBegin()
6126 
    while True:
6127 
      (fname, ftype, fid) = iprot.readFieldBegin()
6128 
      if ftype == TType.STOP:
6129 
        break
6130 
      if fid == 0:
6131 
        if ftype == TType.I32:
6132 
          self.success = iprot.readI32();
6133 
        else:
6134 
          iprot.skip(ftype)
6135 
      elif fid == 1:
6136 
        if ftype == TType.STRUCT:
6137 
          self.ex = TransactionServiceException()
6138 
          self.ex.read(iprot)
6139 
        else:
6140 
          iprot.skip(ftype)
6141 
      else:
6142 
        iprot.skip(ftype)
6143 
      iprot.readFieldEnd()
6144 
    iprot.readStructEnd()
6145 
 
6146 
  def write(self, oprot):
6147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6149 
      return
6150 
    oprot.writeStructBegin('getOrderCount_result')
6151 
    if self.success is not None:
6152 
      oprot.writeFieldBegin('success', TType.I32, 0)
6153 
      oprot.writeI32(self.success)
6154 
      oprot.writeFieldEnd()
6155 
    if self.ex is not None:
6156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6157 
      self.ex.write(oprot)
6158 
      oprot.writeFieldEnd()
6159 
    oprot.writeFieldStop()
6160 
    oprot.writeStructEnd()
6161 
 
6162 
  def validate(self):
6163 
    return
6164 
 
6165 
 
6166 
  def __repr__(self):
6167 
    L = ['%s=%r' % (key, value)
6168 
      for key, value in self.__dict__.iteritems()]
6169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6170 
 
6171 
  def __eq__(self, other):
6172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6173 
 
6174 
  def __ne__(self, other):
6175 
    return not (self == other)
6176 
 
999 varun.gupt 6177 
class getOrdersByBillingDate_args:
6178 
  """
6179 
  Attributes:
6180 
   - status
6181 
   - start_billing_date
6182 
   - end_billing_date
6183 
   - warehouse_id
6184 
  """
6185 
 
6186 
  thrift_spec = (
6187 
    None, # 0
6188 
    (1, TType.I32, 'status', None, None, ), # 1
6189 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6190 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6191 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6192 
  )
6193 
 
6194 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6195 
    self.status = status
6196 
    self.start_billing_date = start_billing_date
6197 
    self.end_billing_date = end_billing_date
6198 
    self.warehouse_id = warehouse_id
6199 
 
6200 
  def read(self, iprot):
6201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6203 
      return
6204 
    iprot.readStructBegin()
6205 
    while True:
6206 
      (fname, ftype, fid) = iprot.readFieldBegin()
6207 
      if ftype == TType.STOP:
6208 
        break
6209 
      if fid == 1:
6210 
        if ftype == TType.I32:
6211 
          self.status = iprot.readI32();
6212 
        else:
6213 
          iprot.skip(ftype)
6214 
      elif fid == 2:
6215 
        if ftype == TType.I64:
6216 
          self.start_billing_date = iprot.readI64();
6217 
        else:
6218 
          iprot.skip(ftype)
6219 
      elif fid == 3:
6220 
        if ftype == TType.I64:
6221 
          self.end_billing_date = iprot.readI64();
6222 
        else:
6223 
          iprot.skip(ftype)
6224 
      elif fid == 4:
6225 
        if ftype == TType.I64:
6226 
          self.warehouse_id = iprot.readI64();
6227 
        else:
6228 
          iprot.skip(ftype)
6229 
      else:
6230 
        iprot.skip(ftype)
6231 
      iprot.readFieldEnd()
6232 
    iprot.readStructEnd()
6233 
 
6234 
  def write(self, oprot):
6235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6237 
      return
6238 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6239 
    if self.status is not None:
999 varun.gupt 6240 
      oprot.writeFieldBegin('status', TType.I32, 1)
6241 
      oprot.writeI32(self.status)
6242 
      oprot.writeFieldEnd()
3431 rajveer 6243 
    if self.start_billing_date is not None:
999 varun.gupt 6244 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6245 
      oprot.writeI64(self.start_billing_date)
6246 
      oprot.writeFieldEnd()
3431 rajveer 6247 
    if self.end_billing_date is not None:
999 varun.gupt 6248 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6249 
      oprot.writeI64(self.end_billing_date)
6250 
      oprot.writeFieldEnd()
3431 rajveer 6251 
    if self.warehouse_id is not None:
999 varun.gupt 6252 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6253 
      oprot.writeI64(self.warehouse_id)
6254 
      oprot.writeFieldEnd()
6255 
    oprot.writeFieldStop()
6256 
    oprot.writeStructEnd()
6257 
 
3431 rajveer 6258 
  def validate(self):
6259 
    return
6260 
 
6261 
 
999 varun.gupt 6262 
  def __repr__(self):
6263 
    L = ['%s=%r' % (key, value)
6264 
      for key, value in self.__dict__.iteritems()]
6265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6266 
 
6267 
  def __eq__(self, other):
6268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6269 
 
6270 
  def __ne__(self, other):
6271 
    return not (self == other)
6272 
 
6273 
class getOrdersByBillingDate_result:
6274 
  """
6275 
  Attributes:
6276 
   - success
6277 
   - ex
6278 
  """
6279 
 
6280 
  thrift_spec = (
6281 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6283 
  )
6284 
 
6285 
  def __init__(self, success=None, ex=None,):
6286 
    self.success = success
6287 
    self.ex = ex
6288 
 
6289 
  def read(self, iprot):
6290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6292 
      return
6293 
    iprot.readStructBegin()
6294 
    while True:
6295 
      (fname, ftype, fid) = iprot.readFieldBegin()
6296 
      if ftype == TType.STOP:
6297 
        break
6298 
      if fid == 0:
6299 
        if ftype == TType.LIST:
6300 
          self.success = []
4133 chandransh 6301 
          (_etype59, _size56) = iprot.readListBegin()
6302 
          for _i60 in xrange(_size56):
6303 
            _elem61 = Order()
6304 
            _elem61.read(iprot)
6305 
            self.success.append(_elem61)
999 varun.gupt 6306 
          iprot.readListEnd()
6307 
        else:
6308 
          iprot.skip(ftype)
6309 
      elif fid == 1:
6310 
        if ftype == TType.STRUCT:
6311 
          self.ex = TransactionServiceException()
6312 
          self.ex.read(iprot)
6313 
        else:
6314 
          iprot.skip(ftype)
6315 
      else:
6316 
        iprot.skip(ftype)
6317 
      iprot.readFieldEnd()
6318 
    iprot.readStructEnd()
6319 
 
6320 
  def write(self, oprot):
6321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6323 
      return
6324 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6325 
    if self.success is not None:
999 varun.gupt 6326 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6327 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6328 
      for iter62 in self.success:
6329 
        iter62.write(oprot)
999 varun.gupt 6330 
      oprot.writeListEnd()
6331 
      oprot.writeFieldEnd()
3431 rajveer 6332 
    if self.ex is not None:
999 varun.gupt 6333 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6334 
      self.ex.write(oprot)
6335 
      oprot.writeFieldEnd()
6336 
    oprot.writeFieldStop()
6337 
    oprot.writeStructEnd()
6338 
 
3431 rajveer 6339 
  def validate(self):
6340 
    return
6341 
 
6342 
 
999 varun.gupt 6343 
  def __repr__(self):
6344 
    L = ['%s=%r' % (key, value)
6345 
      for key, value in self.__dict__.iteritems()]
6346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6347 
 
6348 
  def __eq__(self, other):
6349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6350 
 
6351 
  def __ne__(self, other):
6352 
    return not (self == other)
6353 
 
3427 chandransh 6354 
class getOrdersByShippingDate_args:
6355 
  """
6356 
  Attributes:
6357 
   - fromShippingDate
6358 
   - toShippingDate
6359 
   - providerId
6360 
   - warehouseId
3451 chandransh 6361 
   - cod
3427 chandransh 6362 
  """
6363 
 
6364 
  thrift_spec = (
6365 
    None, # 0
6366 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6367 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6368 
    (3, TType.I64, 'providerId', None, None, ), # 3
6369 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6370 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6371 
  )
6372 
 
3451 chandransh 6373 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6374 
    self.fromShippingDate = fromShippingDate
6375 
    self.toShippingDate = toShippingDate
6376 
    self.providerId = providerId
6377 
    self.warehouseId = warehouseId
3451 chandransh 6378 
    self.cod = cod
3427 chandransh 6379 
 
6380 
  def read(self, iprot):
6381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6383 
      return
6384 
    iprot.readStructBegin()
6385 
    while True:
6386 
      (fname, ftype, fid) = iprot.readFieldBegin()
6387 
      if ftype == TType.STOP:
6388 
        break
6389 
      if fid == 1:
6390 
        if ftype == TType.I64:
6391 
          self.fromShippingDate = iprot.readI64();
6392 
        else:
6393 
          iprot.skip(ftype)
6394 
      elif fid == 2:
6395 
        if ftype == TType.I64:
6396 
          self.toShippingDate = iprot.readI64();
6397 
        else:
6398 
          iprot.skip(ftype)
6399 
      elif fid == 3:
6400 
        if ftype == TType.I64:
6401 
          self.providerId = iprot.readI64();
6402 
        else:
6403 
          iprot.skip(ftype)
6404 
      elif fid == 4:
6405 
        if ftype == TType.I64:
6406 
          self.warehouseId = iprot.readI64();
6407 
        else:
6408 
          iprot.skip(ftype)
3451 chandransh 6409 
      elif fid == 5:
6410 
        if ftype == TType.BOOL:
6411 
          self.cod = iprot.readBool();
6412 
        else:
6413 
          iprot.skip(ftype)
3427 chandransh 6414 
      else:
6415 
        iprot.skip(ftype)
6416 
      iprot.readFieldEnd()
6417 
    iprot.readStructEnd()
6418 
 
6419 
  def write(self, oprot):
6420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6422 
      return
6423 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6424 
    if self.fromShippingDate is not None:
3427 chandransh 6425 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6426 
      oprot.writeI64(self.fromShippingDate)
6427 
      oprot.writeFieldEnd()
3431 rajveer 6428 
    if self.toShippingDate is not None:
3427 chandransh 6429 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6430 
      oprot.writeI64(self.toShippingDate)
6431 
      oprot.writeFieldEnd()
3431 rajveer 6432 
    if self.providerId is not None:
3427 chandransh 6433 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6434 
      oprot.writeI64(self.providerId)
6435 
      oprot.writeFieldEnd()
3431 rajveer 6436 
    if self.warehouseId is not None:
3427 chandransh 6437 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6438 
      oprot.writeI64(self.warehouseId)
6439 
      oprot.writeFieldEnd()
3451 chandransh 6440 
    if self.cod is not None:
6441 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6442 
      oprot.writeBool(self.cod)
6443 
      oprot.writeFieldEnd()
3427 chandransh 6444 
    oprot.writeFieldStop()
6445 
    oprot.writeStructEnd()
6446 
 
3431 rajveer 6447 
  def validate(self):
6448 
    return
6449 
 
6450 
 
3427 chandransh 6451 
  def __repr__(self):
6452 
    L = ['%s=%r' % (key, value)
6453 
      for key, value in self.__dict__.iteritems()]
6454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6455 
 
6456 
  def __eq__(self, other):
6457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6458 
 
6459 
  def __ne__(self, other):
6460 
    return not (self == other)
6461 
 
6462 
class getOrdersByShippingDate_result:
6463 
  """
6464 
  Attributes:
6465 
   - success
6466 
   - ex
6467 
  """
6468 
 
6469 
  thrift_spec = (
6470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6472 
  )
6473 
 
6474 
  def __init__(self, success=None, ex=None,):
6475 
    self.success = success
6476 
    self.ex = ex
6477 
 
6478 
  def read(self, iprot):
6479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6481 
      return
6482 
    iprot.readStructBegin()
6483 
    while True:
6484 
      (fname, ftype, fid) = iprot.readFieldBegin()
6485 
      if ftype == TType.STOP:
6486 
        break
6487 
      if fid == 0:
6488 
        if ftype == TType.LIST:
6489 
          self.success = []
4133 chandransh 6490 
          (_etype66, _size63) = iprot.readListBegin()
6491 
          for _i67 in xrange(_size63):
6492 
            _elem68 = Order()
6493 
            _elem68.read(iprot)
6494 
            self.success.append(_elem68)
3427 chandransh 6495 
          iprot.readListEnd()
6496 
        else:
6497 
          iprot.skip(ftype)
6498 
      elif fid == 1:
6499 
        if ftype == TType.STRUCT:
6500 
          self.ex = TransactionServiceException()
6501 
          self.ex.read(iprot)
6502 
        else:
6503 
          iprot.skip(ftype)
6504 
      else:
6505 
        iprot.skip(ftype)
6506 
      iprot.readFieldEnd()
6507 
    iprot.readStructEnd()
6508 
 
6509 
  def write(self, oprot):
6510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6512 
      return
6513 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6514 
    if self.success is not None:
3427 chandransh 6515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6517 
      for iter69 in self.success:
6518 
        iter69.write(oprot)
3427 chandransh 6519 
      oprot.writeListEnd()
6520 
      oprot.writeFieldEnd()
3431 rajveer 6521 
    if self.ex is not None:
3427 chandransh 6522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6523 
      self.ex.write(oprot)
6524 
      oprot.writeFieldEnd()
6525 
    oprot.writeFieldStop()
6526 
    oprot.writeStructEnd()
6527 
 
3431 rajveer 6528 
  def validate(self):
6529 
    return
6530 
 
6531 
 
3427 chandransh 6532 
  def __repr__(self):
6533 
    L = ['%s=%r' % (key, value)
6534 
      for key, value in self.__dict__.iteritems()]
6535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6536 
 
6537 
  def __eq__(self, other):
6538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6539 
 
6540 
  def __ne__(self, other):
6541 
    return not (self == other)
6542 
 
1382 varun.gupt 6543 
class getReturnableOrdersForCustomer_args:
6544 
  """
6545 
  Attributes:
6546 
   - customer_id
6547 
   - limit
6548 
  """
6549 
 
6550 
  thrift_spec = (
6551 
    None, # 0
6552 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6553 
    (2, TType.I64, 'limit', None, None, ), # 2
6554 
  )
6555 
 
6556 
  def __init__(self, customer_id=None, limit=None,):
6557 
    self.customer_id = customer_id
6558 
    self.limit = limit
6559 
 
6560 
  def read(self, iprot):
6561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6563 
      return
6564 
    iprot.readStructBegin()
6565 
    while True:
6566 
      (fname, ftype, fid) = iprot.readFieldBegin()
6567 
      if ftype == TType.STOP:
6568 
        break
6569 
      if fid == 1:
6570 
        if ftype == TType.I64:
6571 
          self.customer_id = iprot.readI64();
6572 
        else:
6573 
          iprot.skip(ftype)
6574 
      elif fid == 2:
6575 
        if ftype == TType.I64:
6576 
          self.limit = iprot.readI64();
6577 
        else:
6578 
          iprot.skip(ftype)
6579 
      else:
6580 
        iprot.skip(ftype)
6581 
      iprot.readFieldEnd()
6582 
    iprot.readStructEnd()
6583 
 
6584 
  def write(self, oprot):
6585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6587 
      return
6588 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6589 
    if self.customer_id is not None:
1382 varun.gupt 6590 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6591 
      oprot.writeI64(self.customer_id)
6592 
      oprot.writeFieldEnd()
3431 rajveer 6593 
    if self.limit is not None:
1382 varun.gupt 6594 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6595 
      oprot.writeI64(self.limit)
6596 
      oprot.writeFieldEnd()
6597 
    oprot.writeFieldStop()
6598 
    oprot.writeStructEnd()
6599 
 
3431 rajveer 6600 
  def validate(self):
6601 
    return
6602 
 
6603 
 
1382 varun.gupt 6604 
  def __repr__(self):
6605 
    L = ['%s=%r' % (key, value)
6606 
      for key, value in self.__dict__.iteritems()]
6607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6608 
 
6609 
  def __eq__(self, other):
6610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6611 
 
6612 
  def __ne__(self, other):
6613 
    return not (self == other)
6614 
 
6615 
class getReturnableOrdersForCustomer_result:
6616 
  """
6617 
  Attributes:
6618 
   - success
6619 
   - ex
6620 
  """
6621 
 
6622 
  thrift_spec = (
6623 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6625 
  )
6626 
 
6627 
  def __init__(self, success=None, ex=None,):
6628 
    self.success = success
6629 
    self.ex = ex
6630 
 
6631 
  def read(self, iprot):
6632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6634 
      return
6635 
    iprot.readStructBegin()
6636 
    while True:
6637 
      (fname, ftype, fid) = iprot.readFieldBegin()
6638 
      if ftype == TType.STOP:
6639 
        break
6640 
      if fid == 0:
6641 
        if ftype == TType.LIST:
6642 
          self.success = []
4133 chandransh 6643 
          (_etype73, _size70) = iprot.readListBegin()
6644 
          for _i74 in xrange(_size70):
6645 
            _elem75 = iprot.readI64();
6646 
            self.success.append(_elem75)
1382 varun.gupt 6647 
          iprot.readListEnd()
6648 
        else:
6649 
          iprot.skip(ftype)
6650 
      elif fid == 1:
6651 
        if ftype == TType.STRUCT:
6652 
          self.ex = TransactionServiceException()
6653 
          self.ex.read(iprot)
6654 
        else:
6655 
          iprot.skip(ftype)
6656 
      else:
6657 
        iprot.skip(ftype)
6658 
      iprot.readFieldEnd()
6659 
    iprot.readStructEnd()
6660 
 
6661 
  def write(self, oprot):
6662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6664 
      return
6665 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6666 
    if self.success is not None:
1382 varun.gupt 6667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6668 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6669 
      for iter76 in self.success:
6670 
        oprot.writeI64(iter76)
1382 varun.gupt 6671 
      oprot.writeListEnd()
6672 
      oprot.writeFieldEnd()
3431 rajveer 6673 
    if self.ex is not None:
1382 varun.gupt 6674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6675 
      self.ex.write(oprot)
6676 
      oprot.writeFieldEnd()
6677 
    oprot.writeFieldStop()
6678 
    oprot.writeStructEnd()
6679 
 
3431 rajveer 6680 
  def validate(self):
6681 
    return
6682 
 
6683 
 
1382 varun.gupt 6684 
  def __repr__(self):
6685 
    L = ['%s=%r' % (key, value)
6686 
      for key, value in self.__dict__.iteritems()]
6687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6688 
 
6689 
  def __eq__(self, other):
6690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6691 
 
6692 
  def __ne__(self, other):
6693 
    return not (self == other)
6694 
 
6695 
class getCancellableOrdersForCustomer_args:
6696 
  """
6697 
  Attributes:
6698 
   - customer_id
6699 
   - limit
6700 
  """
6701 
 
6702 
  thrift_spec = (
6703 
    None, # 0
6704 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6705 
    (2, TType.I64, 'limit', None, None, ), # 2
6706 
  )
6707 
 
6708 
  def __init__(self, customer_id=None, limit=None,):
6709 
    self.customer_id = customer_id
6710 
    self.limit = limit
6711 
 
6712 
  def read(self, iprot):
6713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6715 
      return
6716 
    iprot.readStructBegin()
6717 
    while True:
6718 
      (fname, ftype, fid) = iprot.readFieldBegin()
6719 
      if ftype == TType.STOP:
6720 
        break
6721 
      if fid == 1:
6722 
        if ftype == TType.I64:
6723 
          self.customer_id = iprot.readI64();
6724 
        else:
6725 
          iprot.skip(ftype)
6726 
      elif fid == 2:
6727 
        if ftype == TType.I64:
6728 
          self.limit = iprot.readI64();
6729 
        else:
6730 
          iprot.skip(ftype)
6731 
      else:
6732 
        iprot.skip(ftype)
6733 
      iprot.readFieldEnd()
6734 
    iprot.readStructEnd()
6735 
 
6736 
  def write(self, oprot):
6737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6739 
      return
6740 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6741 
    if self.customer_id is not None:
1382 varun.gupt 6742 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6743 
      oprot.writeI64(self.customer_id)
6744 
      oprot.writeFieldEnd()
3431 rajveer 6745 
    if self.limit is not None:
1382 varun.gupt 6746 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6747 
      oprot.writeI64(self.limit)
6748 
      oprot.writeFieldEnd()
6749 
    oprot.writeFieldStop()
6750 
    oprot.writeStructEnd()
6751 
 
3431 rajveer 6752 
  def validate(self):
6753 
    return
6754 
 
6755 
 
1382 varun.gupt 6756 
  def __repr__(self):
6757 
    L = ['%s=%r' % (key, value)
6758 
      for key, value in self.__dict__.iteritems()]
6759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6760 
 
6761 
  def __eq__(self, other):
6762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6763 
 
6764 
  def __ne__(self, other):
6765 
    return not (self == other)
6766 
 
6767 
class getCancellableOrdersForCustomer_result:
6768 
  """
6769 
  Attributes:
6770 
   - success
6771 
   - ex
6772 
  """
6773 
 
6774 
  thrift_spec = (
6775 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6777 
  )
6778 
 
6779 
  def __init__(self, success=None, ex=None,):
6780 
    self.success = success
6781 
    self.ex = ex
6782 
 
6783 
  def read(self, iprot):
6784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6786 
      return
6787 
    iprot.readStructBegin()
6788 
    while True:
6789 
      (fname, ftype, fid) = iprot.readFieldBegin()
6790 
      if ftype == TType.STOP:
6791 
        break
6792 
      if fid == 0:
6793 
        if ftype == TType.LIST:
6794 
          self.success = []
4133 chandransh 6795 
          (_etype80, _size77) = iprot.readListBegin()
6796 
          for _i81 in xrange(_size77):
6797 
            _elem82 = iprot.readI64();
6798 
            self.success.append(_elem82)
1382 varun.gupt 6799 
          iprot.readListEnd()
6800 
        else:
6801 
          iprot.skip(ftype)
6802 
      elif fid == 1:
6803 
        if ftype == TType.STRUCT:
6804 
          self.ex = TransactionServiceException()
6805 
          self.ex.read(iprot)
6806 
        else:
6807 
          iprot.skip(ftype)
6808 
      else:
6809 
        iprot.skip(ftype)
6810 
      iprot.readFieldEnd()
6811 
    iprot.readStructEnd()
6812 
 
6813 
  def write(self, oprot):
6814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6816 
      return
6817 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6818 
    if self.success is not None:
1382 varun.gupt 6819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6820 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6821 
      for iter83 in self.success:
6822 
        oprot.writeI64(iter83)
1382 varun.gupt 6823 
      oprot.writeListEnd()
6824 
      oprot.writeFieldEnd()
3431 rajveer 6825 
    if self.ex is not None:
1382 varun.gupt 6826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6827 
      self.ex.write(oprot)
6828 
      oprot.writeFieldEnd()
6829 
    oprot.writeFieldStop()
6830 
    oprot.writeStructEnd()
6831 
 
3431 rajveer 6832 
  def validate(self):
6833 
    return
6834 
 
6835 
 
1382 varun.gupt 6836 
  def __repr__(self):
6837 
    L = ['%s=%r' % (key, value)
6838 
      for key, value in self.__dict__.iteritems()]
6839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6840 
 
6841 
  def __eq__(self, other):
6842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6843 
 
6844 
  def __ne__(self, other):
6845 
    return not (self == other)
6846 
 
483 rajveer 6847 
class changeOrderStatus_args:
94 ashish 6848 
  """
6849 
  Attributes:
483 rajveer 6850 
   - orderId
6851 
   - status
6852 
   - description
94 ashish 6853 
  """
6854 
 
6855 
  thrift_spec = (
6856 
    None, # 0
483 rajveer 6857 
    (1, TType.I64, 'orderId', None, None, ), # 1
6858 
    (2, TType.I32, 'status', None, None, ), # 2
6859 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6860 
  )
6861 
 
483 rajveer 6862 
  def __init__(self, orderId=None, status=None, description=None,):
6863 
    self.orderId = orderId
6864 
    self.status = status
6865 
    self.description = description
94 ashish 6866 
 
6867 
  def read(self, iprot):
6868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6870 
      return
6871 
    iprot.readStructBegin()
6872 
    while True:
6873 
      (fname, ftype, fid) = iprot.readFieldBegin()
6874 
      if ftype == TType.STOP:
6875 
        break
6876 
      if fid == 1:
6877 
        if ftype == TType.I64:
483 rajveer 6878 
          self.orderId = iprot.readI64();
94 ashish 6879 
        else:
6880 
          iprot.skip(ftype)
6881 
      elif fid == 2:
483 rajveer 6882 
        if ftype == TType.I32:
6883 
          self.status = iprot.readI32();
94 ashish 6884 
        else:
6885 
          iprot.skip(ftype)
483 rajveer 6886 
      elif fid == 3:
6887 
        if ftype == TType.STRING:
6888 
          self.description = iprot.readString();
6889 
        else:
6890 
          iprot.skip(ftype)
94 ashish 6891 
      else:
6892 
        iprot.skip(ftype)
6893 
      iprot.readFieldEnd()
6894 
    iprot.readStructEnd()
6895 
 
6896 
  def write(self, oprot):
6897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6899 
      return
483 rajveer 6900 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6901 
    if self.orderId is not None:
483 rajveer 6902 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6903 
      oprot.writeI64(self.orderId)
94 ashish 6904 
      oprot.writeFieldEnd()
3431 rajveer 6905 
    if self.status is not None:
483 rajveer 6906 
      oprot.writeFieldBegin('status', TType.I32, 2)
6907 
      oprot.writeI32(self.status)
94 ashish 6908 
      oprot.writeFieldEnd()
3431 rajveer 6909 
    if self.description is not None:
483 rajveer 6910 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6911 
      oprot.writeString(self.description)
6912 
      oprot.writeFieldEnd()
94 ashish 6913 
    oprot.writeFieldStop()
6914 
    oprot.writeStructEnd()
6915 
 
3431 rajveer 6916 
  def validate(self):
6917 
    return
6918 
 
6919 
 
94 ashish 6920 
  def __repr__(self):
6921 
    L = ['%s=%r' % (key, value)
6922 
      for key, value in self.__dict__.iteritems()]
6923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6924 
 
6925 
  def __eq__(self, other):
6926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6927 
 
6928 
  def __ne__(self, other):
6929 
    return not (self == other)
6930 
 
483 rajveer 6931 
class changeOrderStatus_result:
94 ashish 6932 
  """
6933 
  Attributes:
6934 
   - success
6935 
   - ex
6936 
  """
6937 
 
6938 
  thrift_spec = (
6939 
    (0, TType.BOOL, 'success', None, None, ), # 0
6940 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6941 
  )
6942 
 
6943 
  def __init__(self, success=None, ex=None,):
6944 
    self.success = success
6945 
    self.ex = ex
6946 
 
6947 
  def read(self, iprot):
6948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6950 
      return
6951 
    iprot.readStructBegin()
6952 
    while True:
6953 
      (fname, ftype, fid) = iprot.readFieldBegin()
6954 
      if ftype == TType.STOP:
6955 
        break
6956 
      if fid == 0:
6957 
        if ftype == TType.BOOL:
6958 
          self.success = iprot.readBool();
6959 
        else:
6960 
          iprot.skip(ftype)
6961 
      elif fid == 1:
6962 
        if ftype == TType.STRUCT:
6963 
          self.ex = TransactionServiceException()
6964 
          self.ex.read(iprot)
6965 
        else:
6966 
          iprot.skip(ftype)
6967 
      else:
6968 
        iprot.skip(ftype)
6969 
      iprot.readFieldEnd()
6970 
    iprot.readStructEnd()
6971 
 
6972 
  def write(self, oprot):
6973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6975 
      return
483 rajveer 6976 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6977 
    if self.success is not None:
94 ashish 6978 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6979 
      oprot.writeBool(self.success)
6980 
      oprot.writeFieldEnd()
3431 rajveer 6981 
    if self.ex is not None:
94 ashish 6982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6983 
      self.ex.write(oprot)
6984 
      oprot.writeFieldEnd()
6985 
    oprot.writeFieldStop()
6986 
    oprot.writeStructEnd()
6987 
 
3431 rajveer 6988 
  def validate(self):
6989 
    return
6990 
 
6991 
 
94 ashish 6992 
  def __repr__(self):
6993 
    L = ['%s=%r' % (key, value)
6994 
      for key, value in self.__dict__.iteritems()]
6995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6996 
 
6997 
  def __eq__(self, other):
6998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6999 
 
7000 
  def __ne__(self, other):
7001 
    return not (self == other)
7002 
 
3064 chandransh 7003 
class getOrdersForTransaction_args:
494 rajveer 7004 
  """
7005 
  Attributes:
3064 chandransh 7006 
   - transactionId
7007 
   - customerId
494 rajveer 7008 
  """
7009 
 
7010 
  thrift_spec = (
7011 
    None, # 0
3064 chandransh 7012 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7013 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7014 
  )
7015 
 
3064 chandransh 7016 
  def __init__(self, transactionId=None, customerId=None,):
7017 
    self.transactionId = transactionId
7018 
    self.customerId = customerId
494 rajveer 7019 
 
7020 
  def read(self, iprot):
7021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7023 
      return
7024 
    iprot.readStructBegin()
7025 
    while True:
7026 
      (fname, ftype, fid) = iprot.readFieldBegin()
7027 
      if ftype == TType.STOP:
7028 
        break
7029 
      if fid == 1:
7030 
        if ftype == TType.I64:
3064 chandransh 7031 
          self.transactionId = iprot.readI64();
494 rajveer 7032 
        else:
7033 
          iprot.skip(ftype)
7034 
      elif fid == 2:
3064 chandransh 7035 
        if ftype == TType.I64:
7036 
          self.customerId = iprot.readI64();
494 rajveer 7037 
        else:
7038 
          iprot.skip(ftype)
7039 
      else:
7040 
        iprot.skip(ftype)
7041 
      iprot.readFieldEnd()
7042 
    iprot.readStructEnd()
7043 
 
7044 
  def write(self, oprot):
7045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7047 
      return
3064 chandransh 7048 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7049 
    if self.transactionId is not None:
3064 chandransh 7050 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7051 
      oprot.writeI64(self.transactionId)
494 rajveer 7052 
      oprot.writeFieldEnd()
3431 rajveer 7053 
    if self.customerId is not None:
3064 chandransh 7054 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7055 
      oprot.writeI64(self.customerId)
494 rajveer 7056 
      oprot.writeFieldEnd()
7057 
    oprot.writeFieldStop()
7058 
    oprot.writeStructEnd()
7059 
 
3431 rajveer 7060 
  def validate(self):
7061 
    return
7062 
 
7063 
 
494 rajveer 7064 
  def __repr__(self):
7065 
    L = ['%s=%r' % (key, value)
7066 
      for key, value in self.__dict__.iteritems()]
7067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7068 
 
7069 
  def __eq__(self, other):
7070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7071 
 
7072 
  def __ne__(self, other):
7073 
    return not (self == other)
7074 
 
3064 chandransh 7075 
class getOrdersForTransaction_result:
494 rajveer 7076 
  """
7077 
  Attributes:
7078 
   - success
7079 
   - ex
7080 
  """
7081 
 
7082 
  thrift_spec = (
3064 chandransh 7083 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7085 
  )
7086 
 
7087 
  def __init__(self, success=None, ex=None,):
7088 
    self.success = success
7089 
    self.ex = ex
7090 
 
7091 
  def read(self, iprot):
7092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7094 
      return
7095 
    iprot.readStructBegin()
7096 
    while True:
7097 
      (fname, ftype, fid) = iprot.readFieldBegin()
7098 
      if ftype == TType.STOP:
7099 
        break
7100 
      if fid == 0:
3064 chandransh 7101 
        if ftype == TType.LIST:
7102 
          self.success = []
4133 chandransh 7103 
          (_etype87, _size84) = iprot.readListBegin()
7104 
          for _i88 in xrange(_size84):
7105 
            _elem89 = Order()
7106 
            _elem89.read(iprot)
7107 
            self.success.append(_elem89)
3064 chandransh 7108 
          iprot.readListEnd()
494 rajveer 7109 
        else:
7110 
          iprot.skip(ftype)
7111 
      elif fid == 1:
7112 
        if ftype == TType.STRUCT:
7113 
          self.ex = TransactionServiceException()
7114 
          self.ex.read(iprot)
7115 
        else:
7116 
          iprot.skip(ftype)
7117 
      else:
7118 
        iprot.skip(ftype)
7119 
      iprot.readFieldEnd()
7120 
    iprot.readStructEnd()
7121 
 
7122 
  def write(self, oprot):
7123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7125 
      return
3064 chandransh 7126 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7127 
    if self.success is not None:
3064 chandransh 7128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7129 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7130 
      for iter90 in self.success:
7131 
        iter90.write(oprot)
3064 chandransh 7132 
      oprot.writeListEnd()
494 rajveer 7133 
      oprot.writeFieldEnd()
3431 rajveer 7134 
    if self.ex is not None:
494 rajveer 7135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7136 
      self.ex.write(oprot)
7137 
      oprot.writeFieldEnd()
7138 
    oprot.writeFieldStop()
7139 
    oprot.writeStructEnd()
7140 
 
3431 rajveer 7141 
  def validate(self):
7142 
    return
7143 
 
7144 
 
494 rajveer 7145 
  def __repr__(self):
7146 
    L = ['%s=%r' % (key, value)
7147 
      for key, value in self.__dict__.iteritems()]
7148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7149 
 
7150 
  def __eq__(self, other):
7151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7152 
 
7153 
  def __ne__(self, other):
7154 
    return not (self == other)
7155 
 
3064 chandransh 7156 
class getOrdersForCustomer_args:
1149 chandransh 7157 
  """
7158 
  Attributes:
3064 chandransh 7159 
   - customerId
7160 
   - from_date
7161 
   - to_date
7162 
   - statuses
1149 chandransh 7163 
  """
7164 
 
7165 
  thrift_spec = (
7166 
    None, # 0
3064 chandransh 7167 
    (1, TType.I64, 'customerId', None, None, ), # 1
7168 
    (2, TType.I64, 'from_date', None, None, ), # 2
7169 
    (3, TType.I64, 'to_date', None, None, ), # 3
7170 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7171 
  )
7172 
 
3064 chandransh 7173 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7174 
    self.customerId = customerId
7175 
    self.from_date = from_date
7176 
    self.to_date = to_date
7177 
    self.statuses = statuses
1149 chandransh 7178 
 
7179 
  def read(self, iprot):
7180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7182 
      return
7183 
    iprot.readStructBegin()
7184 
    while True:
7185 
      (fname, ftype, fid) = iprot.readFieldBegin()
7186 
      if ftype == TType.STOP:
7187 
        break
7188 
      if fid == 1:
7189 
        if ftype == TType.I64:
3064 chandransh 7190 
          self.customerId = iprot.readI64();
1149 chandransh 7191 
        else:
7192 
          iprot.skip(ftype)
7193 
      elif fid == 2:
7194 
        if ftype == TType.I64:
3064 chandransh 7195 
          self.from_date = iprot.readI64();
1149 chandransh 7196 
        else:
7197 
          iprot.skip(ftype)
2783 chandransh 7198 
      elif fid == 3:
7199 
        if ftype == TType.I64:
3064 chandransh 7200 
          self.to_date = iprot.readI64();
2783 chandransh 7201 
        else:
7202 
          iprot.skip(ftype)
7203 
      elif fid == 4:
3064 chandransh 7204 
        if ftype == TType.LIST:
7205 
          self.statuses = []
4133 chandransh 7206 
          (_etype94, _size91) = iprot.readListBegin()
7207 
          for _i95 in xrange(_size91):
7208 
            _elem96 = iprot.readI32();
7209 
            self.statuses.append(_elem96)
3064 chandransh 7210 
          iprot.readListEnd()
2783 chandransh 7211 
        else:
7212 
          iprot.skip(ftype)
1149 chandransh 7213 
      else:
7214 
        iprot.skip(ftype)
7215 
      iprot.readFieldEnd()
7216 
    iprot.readStructEnd()
7217 
 
7218 
  def write(self, oprot):
7219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7221 
      return
3064 chandransh 7222 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7223 
    if self.customerId is not None:
3064 chandransh 7224 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7225 
      oprot.writeI64(self.customerId)
1149 chandransh 7226 
      oprot.writeFieldEnd()
3431 rajveer 7227 
    if self.from_date is not None:
3064 chandransh 7228 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7229 
      oprot.writeI64(self.from_date)
1149 chandransh 7230 
      oprot.writeFieldEnd()
3431 rajveer 7231 
    if self.to_date is not None:
3064 chandransh 7232 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7233 
      oprot.writeI64(self.to_date)
2783 chandransh 7234 
      oprot.writeFieldEnd()
3431 rajveer 7235 
    if self.statuses is not None:
3064 chandransh 7236 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7237 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7238 
      for iter97 in self.statuses:
7239 
        oprot.writeI32(iter97)
3064 chandransh 7240 
      oprot.writeListEnd()
2783 chandransh 7241 
      oprot.writeFieldEnd()
1149 chandransh 7242 
    oprot.writeFieldStop()
7243 
    oprot.writeStructEnd()
7244 
 
3431 rajveer 7245 
  def validate(self):
7246 
    return
7247 
 
7248 
 
1149 chandransh 7249 
  def __repr__(self):
7250 
    L = ['%s=%r' % (key, value)
7251 
      for key, value in self.__dict__.iteritems()]
7252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7253 
 
7254 
  def __eq__(self, other):
7255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7256 
 
7257 
  def __ne__(self, other):
7258 
    return not (self == other)
7259 
 
3064 chandransh 7260 
class getOrdersForCustomer_result:
1149 chandransh 7261 
  """
7262 
  Attributes:
7263 
   - success
7264 
   - ex
7265 
  """
7266 
 
7267 
  thrift_spec = (
3064 chandransh 7268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7270 
  )
7271 
 
7272 
  def __init__(self, success=None, ex=None,):
7273 
    self.success = success
7274 
    self.ex = ex
7275 
 
7276 
  def read(self, iprot):
7277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7279 
      return
7280 
    iprot.readStructBegin()
7281 
    while True:
7282 
      (fname, ftype, fid) = iprot.readFieldBegin()
7283 
      if ftype == TType.STOP:
7284 
        break
7285 
      if fid == 0:
3064 chandransh 7286 
        if ftype == TType.LIST:
7287 
          self.success = []
4133 chandransh 7288 
          (_etype101, _size98) = iprot.readListBegin()
7289 
          for _i102 in xrange(_size98):
7290 
            _elem103 = Order()
7291 
            _elem103.read(iprot)
7292 
            self.success.append(_elem103)
3064 chandransh 7293 
          iprot.readListEnd()
1149 chandransh 7294 
        else:
7295 
          iprot.skip(ftype)
7296 
      elif fid == 1:
7297 
        if ftype == TType.STRUCT:
7298 
          self.ex = TransactionServiceException()
7299 
          self.ex.read(iprot)
7300 
        else:
7301 
          iprot.skip(ftype)
7302 
      else:
7303 
        iprot.skip(ftype)
7304 
      iprot.readFieldEnd()
7305 
    iprot.readStructEnd()
7306 
 
7307 
  def write(self, oprot):
7308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7310 
      return
3064 chandransh 7311 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7312 
    if self.success is not None:
3064 chandransh 7313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7315 
      for iter104 in self.success:
7316 
        iter104.write(oprot)
3064 chandransh 7317 
      oprot.writeListEnd()
1149 chandransh 7318 
      oprot.writeFieldEnd()
3431 rajveer 7319 
    if self.ex is not None:
1149 chandransh 7320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7321 
      self.ex.write(oprot)
7322 
      oprot.writeFieldEnd()
7323 
    oprot.writeFieldStop()
7324 
    oprot.writeStructEnd()
7325 
 
3431 rajveer 7326 
  def validate(self):
7327 
    return
7328 
 
7329 
 
1149 chandransh 7330 
  def __repr__(self):
7331 
    L = ['%s=%r' % (key, value)
7332 
      for key, value in self.__dict__.iteritems()]
7333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7334 
 
7335 
  def __eq__(self, other):
7336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7337 
 
7338 
  def __ne__(self, other):
7339 
    return not (self == other)
7340 
 
3064 chandransh 7341 
class createOrder_args:
921 rajveer 7342 
  """
7343 
  Attributes:
3064 chandransh 7344 
   - order
921 rajveer 7345 
  """
7346 
 
7347 
  thrift_spec = (
7348 
    None, # 0
3064 chandransh 7349 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7350 
  )
7351 
 
3064 chandransh 7352 
  def __init__(self, order=None,):
7353 
    self.order = order
921 rajveer 7354 
 
7355 
  def read(self, iprot):
7356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7358 
      return
7359 
    iprot.readStructBegin()
7360 
    while True:
7361 
      (fname, ftype, fid) = iprot.readFieldBegin()
7362 
      if ftype == TType.STOP:
7363 
        break
7364 
      if fid == 1:
3064 chandransh 7365 
        if ftype == TType.STRUCT:
7366 
          self.order = Order()
7367 
          self.order.read(iprot)
921 rajveer 7368 
        else:
7369 
          iprot.skip(ftype)
7370 
      else:
7371 
        iprot.skip(ftype)
7372 
      iprot.readFieldEnd()
7373 
    iprot.readStructEnd()
7374 
 
7375 
  def write(self, oprot):
7376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7378 
      return
3064 chandransh 7379 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7380 
    if self.order is not None:
3064 chandransh 7381 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7382 
      self.order.write(oprot)
921 rajveer 7383 
      oprot.writeFieldEnd()
7384 
    oprot.writeFieldStop()
7385 
    oprot.writeStructEnd()
7386 
 
3431 rajveer 7387 
  def validate(self):
7388 
    return
7389 
 
7390 
 
921 rajveer 7391 
  def __repr__(self):
7392 
    L = ['%s=%r' % (key, value)
7393 
      for key, value in self.__dict__.iteritems()]
7394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7395 
 
7396 
  def __eq__(self, other):
7397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7398 
 
7399 
  def __ne__(self, other):
7400 
    return not (self == other)
7401 
 
3064 chandransh 7402 
class createOrder_result:
921 rajveer 7403 
  """
7404 
  Attributes:
7405 
   - success
7406 
   - ex
7407 
  """
7408 
 
7409 
  thrift_spec = (
3064 chandransh 7410 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7412 
  )
7413 
 
7414 
  def __init__(self, success=None, ex=None,):
7415 
    self.success = success
7416 
    self.ex = ex
7417 
 
7418 
  def read(self, iprot):
7419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7421 
      return
7422 
    iprot.readStructBegin()
7423 
    while True:
7424 
      (fname, ftype, fid) = iprot.readFieldBegin()
7425 
      if ftype == TType.STOP:
7426 
        break
7427 
      if fid == 0:
3064 chandransh 7428 
        if ftype == TType.I64:
7429 
          self.success = iprot.readI64();
921 rajveer 7430 
        else:
7431 
          iprot.skip(ftype)
7432 
      elif fid == 1:
7433 
        if ftype == TType.STRUCT:
7434 
          self.ex = TransactionServiceException()
7435 
          self.ex.read(iprot)
7436 
        else:
7437 
          iprot.skip(ftype)
7438 
      else:
7439 
        iprot.skip(ftype)
7440 
      iprot.readFieldEnd()
7441 
    iprot.readStructEnd()
7442 
 
7443 
  def write(self, oprot):
7444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7446 
      return
3064 chandransh 7447 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7448 
    if self.success is not None:
3064 chandransh 7449 
      oprot.writeFieldBegin('success', TType.I64, 0)
7450 
      oprot.writeI64(self.success)
921 rajveer 7451 
      oprot.writeFieldEnd()
3431 rajveer 7452 
    if self.ex is not None:
921 rajveer 7453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7454 
      self.ex.write(oprot)
7455 
      oprot.writeFieldEnd()
7456 
    oprot.writeFieldStop()
7457 
    oprot.writeStructEnd()
7458 
 
3431 rajveer 7459 
  def validate(self):
7460 
    return
7461 
 
7462 
 
921 rajveer 7463 
  def __repr__(self):
7464 
    L = ['%s=%r' % (key, value)
7465 
      for key, value in self.__dict__.iteritems()]
7466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7467 
 
7468 
  def __eq__(self, other):
7469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7470 
 
7471 
  def __ne__(self, other):
7472 
    return not (self == other)
7473 
 
3064 chandransh 7474 
class getOrder_args:
921 rajveer 7475 
  """
7476 
  Attributes:
3064 chandransh 7477 
   - id
921 rajveer 7478 
  """
7479 
 
7480 
  thrift_spec = (
7481 
    None, # 0
3064 chandransh 7482 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7483 
  )
7484 
 
3064 chandransh 7485 
  def __init__(self, id=None,):
7486 
    self.id = id
921 rajveer 7487 
 
7488 
  def read(self, iprot):
7489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7491 
      return
7492 
    iprot.readStructBegin()
7493 
    while True:
7494 
      (fname, ftype, fid) = iprot.readFieldBegin()
7495 
      if ftype == TType.STOP:
7496 
        break
7497 
      if fid == 1:
7498 
        if ftype == TType.I64:
3064 chandransh 7499 
          self.id = iprot.readI64();
921 rajveer 7500 
        else:
7501 
          iprot.skip(ftype)
7502 
      else:
7503 
        iprot.skip(ftype)
7504 
      iprot.readFieldEnd()
7505 
    iprot.readStructEnd()
7506 
 
7507 
  def write(self, oprot):
7508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7510 
      return
3064 chandransh 7511 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7512 
    if self.id is not None:
3064 chandransh 7513 
      oprot.writeFieldBegin('id', TType.I64, 1)
7514 
      oprot.writeI64(self.id)
921 rajveer 7515 
      oprot.writeFieldEnd()
7516 
    oprot.writeFieldStop()
7517 
    oprot.writeStructEnd()
7518 
 
3431 rajveer 7519 
  def validate(self):
7520 
    return
7521 
 
7522 
 
921 rajveer 7523 
  def __repr__(self):
7524 
    L = ['%s=%r' % (key, value)
7525 
      for key, value in self.__dict__.iteritems()]
7526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7527 
 
7528 
  def __eq__(self, other):
7529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7530 
 
7531 
  def __ne__(self, other):
7532 
    return not (self == other)
7533 
 
3064 chandransh 7534 
class getOrder_result:
921 rajveer 7535 
  """
7536 
  Attributes:
7537 
   - success
7538 
   - ex
7539 
  """
7540 
 
7541 
  thrift_spec = (
3064 chandransh 7542 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7544 
  )
7545 
 
7546 
  def __init__(self, success=None, ex=None,):
7547 
    self.success = success
7548 
    self.ex = ex
7549 
 
7550 
  def read(self, iprot):
7551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7553 
      return
7554 
    iprot.readStructBegin()
7555 
    while True:
7556 
      (fname, ftype, fid) = iprot.readFieldBegin()
7557 
      if ftype == TType.STOP:
7558 
        break
7559 
      if fid == 0:
3064 chandransh 7560 
        if ftype == TType.STRUCT:
7561 
          self.success = Order()
7562 
          self.success.read(iprot)
921 rajveer 7563 
        else:
7564 
          iprot.skip(ftype)
7565 
      elif fid == 1:
7566 
        if ftype == TType.STRUCT:
7567 
          self.ex = TransactionServiceException()
7568 
          self.ex.read(iprot)
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      else:
7572 
        iprot.skip(ftype)
7573 
      iprot.readFieldEnd()
7574 
    iprot.readStructEnd()
7575 
 
7576 
  def write(self, oprot):
7577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7579 
      return
3064 chandransh 7580 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7581 
    if self.success is not None:
3064 chandransh 7582 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7583 
      self.success.write(oprot)
921 rajveer 7584 
      oprot.writeFieldEnd()
3431 rajveer 7585 
    if self.ex is not None:
921 rajveer 7586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7587 
      self.ex.write(oprot)
7588 
      oprot.writeFieldEnd()
7589 
    oprot.writeFieldStop()
7590 
    oprot.writeStructEnd()
7591 
 
3431 rajveer 7592 
  def validate(self):
7593 
    return
7594 
 
7595 
 
921 rajveer 7596 
  def __repr__(self):
7597 
    L = ['%s=%r' % (key, value)
7598 
      for key, value in self.__dict__.iteritems()]
7599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7600 
 
7601 
  def __eq__(self, other):
7602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7603 
 
7604 
  def __ne__(self, other):
7605 
    return not (self == other)
7606 
 
3064 chandransh 7607 
class getLineItemsForOrder_args:
94 ashish 7608 
  """
7609 
  Attributes:
3064 chandransh 7610 
   - orderId
94 ashish 7611 
  """
7612 
 
7613 
  thrift_spec = (
7614 
    None, # 0
3064 chandransh 7615 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7616 
  )
7617 
 
3064 chandransh 7618 
  def __init__(self, orderId=None,):
7619 
    self.orderId = orderId
94 ashish 7620 
 
7621 
  def read(self, iprot):
7622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7624 
      return
7625 
    iprot.readStructBegin()
7626 
    while True:
7627 
      (fname, ftype, fid) = iprot.readFieldBegin()
7628 
      if ftype == TType.STOP:
7629 
        break
7630 
      if fid == 1:
7631 
        if ftype == TType.I64:
3064 chandransh 7632 
          self.orderId = iprot.readI64();
94 ashish 7633 
        else:
7634 
          iprot.skip(ftype)
7635 
      else:
7636 
        iprot.skip(ftype)
7637 
      iprot.readFieldEnd()
7638 
    iprot.readStructEnd()
7639 
 
7640 
  def write(self, oprot):
7641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7643 
      return
3064 chandransh 7644 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7645 
    if self.orderId is not None:
3064 chandransh 7646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7647 
      oprot.writeI64(self.orderId)
94 ashish 7648 
      oprot.writeFieldEnd()
7649 
    oprot.writeFieldStop()
7650 
    oprot.writeStructEnd()
7651 
 
3431 rajveer 7652 
  def validate(self):
7653 
    return
7654 
 
7655 
 
94 ashish 7656 
  def __repr__(self):
7657 
    L = ['%s=%r' % (key, value)
7658 
      for key, value in self.__dict__.iteritems()]
7659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7660 
 
7661 
  def __eq__(self, other):
7662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7663 
 
7664 
  def __ne__(self, other):
7665 
    return not (self == other)
7666 
 
3064 chandransh 7667 
class getLineItemsForOrder_result:
94 ashish 7668 
  """
7669 
  Attributes:
7670 
   - success
7671 
   - ex
7672 
  """
7673 
 
7674 
  thrift_spec = (
3064 chandransh 7675 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7677 
  )
7678 
 
7679 
  def __init__(self, success=None, ex=None,):
7680 
    self.success = success
7681 
    self.ex = ex
7682 
 
7683 
  def read(self, iprot):
7684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7686 
      return
7687 
    iprot.readStructBegin()
7688 
    while True:
7689 
      (fname, ftype, fid) = iprot.readFieldBegin()
7690 
      if ftype == TType.STOP:
7691 
        break
7692 
      if fid == 0:
483 rajveer 7693 
        if ftype == TType.LIST:
7694 
          self.success = []
4133 chandransh 7695 
          (_etype108, _size105) = iprot.readListBegin()
7696 
          for _i109 in xrange(_size105):
7697 
            _elem110 = LineItem()
7698 
            _elem110.read(iprot)
7699 
            self.success.append(_elem110)
483 rajveer 7700 
          iprot.readListEnd()
94 ashish 7701 
        else:
7702 
          iprot.skip(ftype)
7703 
      elif fid == 1:
7704 
        if ftype == TType.STRUCT:
7705 
          self.ex = TransactionServiceException()
7706 
          self.ex.read(iprot)
7707 
        else:
7708 
          iprot.skip(ftype)
7709 
      else:
7710 
        iprot.skip(ftype)
7711 
      iprot.readFieldEnd()
7712 
    iprot.readStructEnd()
7713 
 
7714 
  def write(self, oprot):
7715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7717 
      return
3064 chandransh 7718 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7719 
    if self.success is not None:
483 rajveer 7720 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7721 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7722 
      for iter111 in self.success:
7723 
        iter111.write(oprot)
483 rajveer 7724 
      oprot.writeListEnd()
94 ashish 7725 
      oprot.writeFieldEnd()
3431 rajveer 7726 
    if self.ex is not None:
94 ashish 7727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7728 
      self.ex.write(oprot)
7729 
      oprot.writeFieldEnd()
7730 
    oprot.writeFieldStop()
7731 
    oprot.writeStructEnd()
7732 
 
3431 rajveer 7733 
  def validate(self):
7734 
    return
7735 
 
7736 
 
94 ashish 7737 
  def __repr__(self):
7738 
    L = ['%s=%r' % (key, value)
7739 
      for key, value in self.__dict__.iteritems()]
7740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7741 
 
7742 
  def __eq__(self, other):
7743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7744 
 
7745 
  def __ne__(self, other):
7746 
    return not (self == other)
7747 
 
3064 chandransh 7748 
class getOrderForCustomer_args:
94 ashish 7749 
  """
7750 
  Attributes:
3064 chandransh 7751 
   - orderId
483 rajveer 7752 
   - customerId
94 ashish 7753 
  """
7754 
 
7755 
  thrift_spec = (
7756 
    None, # 0
3064 chandransh 7757 
    (1, TType.I64, 'orderId', None, None, ), # 1
7758 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7759 
  )
7760 
 
3064 chandransh 7761 
  def __init__(self, orderId=None, customerId=None,):
7762 
    self.orderId = orderId
483 rajveer 7763 
    self.customerId = customerId
94 ashish 7764 
 
7765 
  def read(self, iprot):
7766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7768 
      return
7769 
    iprot.readStructBegin()
7770 
    while True:
7771 
      (fname, ftype, fid) = iprot.readFieldBegin()
7772 
      if ftype == TType.STOP:
7773 
        break
7774 
      if fid == 1:
7775 
        if ftype == TType.I64:
3064 chandransh 7776 
          self.orderId = iprot.readI64();
94 ashish 7777 
        else:
7778 
          iprot.skip(ftype)
7779 
      elif fid == 2:
7780 
        if ftype == TType.I64:
3064 chandransh 7781 
          self.customerId = iprot.readI64();
94 ashish 7782 
        else:
7783 
          iprot.skip(ftype)
7784 
      else:
7785 
        iprot.skip(ftype)
7786 
      iprot.readFieldEnd()
7787 
    iprot.readStructEnd()
7788 
 
7789 
  def write(self, oprot):
7790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7792 
      return
3064 chandransh 7793 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7794 
    if self.orderId is not None:
3064 chandransh 7795 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7796 
      oprot.writeI64(self.orderId)
7797 
      oprot.writeFieldEnd()
3431 rajveer 7798 
    if self.customerId is not None:
3064 chandransh 7799 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7800 
      oprot.writeI64(self.customerId)
94 ashish 7801 
      oprot.writeFieldEnd()
7802 
    oprot.writeFieldStop()
7803 
    oprot.writeStructEnd()
7804 
 
3431 rajveer 7805 
  def validate(self):
7806 
    return
7807 
 
7808 
 
94 ashish 7809 
  def __repr__(self):
7810 
    L = ['%s=%r' % (key, value)
7811 
      for key, value in self.__dict__.iteritems()]
7812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7813 
 
7814 
  def __eq__(self, other):
7815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7816 
 
7817 
  def __ne__(self, other):
7818 
    return not (self == other)
7819 
 
3064 chandransh 7820 
class getOrderForCustomer_result:
94 ashish 7821 
  """
7822 
  Attributes:
7823 
   - success
7824 
   - ex
7825 
  """
7826 
 
7827 
  thrift_spec = (
3064 chandransh 7828 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7830 
  )
7831 
 
7832 
  def __init__(self, success=None, ex=None,):
7833 
    self.success = success
7834 
    self.ex = ex
7835 
 
7836 
  def read(self, iprot):
7837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7839 
      return
7840 
    iprot.readStructBegin()
7841 
    while True:
7842 
      (fname, ftype, fid) = iprot.readFieldBegin()
7843 
      if ftype == TType.STOP:
7844 
        break
7845 
      if fid == 0:
3064 chandransh 7846 
        if ftype == TType.STRUCT:
7847 
          self.success = Order()
7848 
          self.success.read(iprot)
94 ashish 7849 
        else:
7850 
          iprot.skip(ftype)
7851 
      elif fid == 1:
7852 
        if ftype == TType.STRUCT:
7853 
          self.ex = TransactionServiceException()
7854 
          self.ex.read(iprot)
7855 
        else:
7856 
          iprot.skip(ftype)
7857 
      else:
7858 
        iprot.skip(ftype)
7859 
      iprot.readFieldEnd()
7860 
    iprot.readStructEnd()
7861 
 
7862 
  def write(self, oprot):
7863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7865 
      return
3064 chandransh 7866 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7867 
    if self.success is not None:
3064 chandransh 7868 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7869 
      self.success.write(oprot)
94 ashish 7870 
      oprot.writeFieldEnd()
3431 rajveer 7871 
    if self.ex is not None:
94 ashish 7872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7873 
      self.ex.write(oprot)
7874 
      oprot.writeFieldEnd()
7875 
    oprot.writeFieldStop()
7876 
    oprot.writeStructEnd()
7877 
 
3431 rajveer 7878 
  def validate(self):
7879 
    return
7880 
 
7881 
 
94 ashish 7882 
  def __repr__(self):
7883 
    L = ['%s=%r' % (key, value)
7884 
      for key, value in self.__dict__.iteritems()]
7885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7886 
 
7887 
  def __eq__(self, other):
7888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7889 
 
7890 
  def __ne__(self, other):
7891 
    return not (self == other)
7892 
 
3064 chandransh 7893 
class getAlerts_args:
94 ashish 7894 
  """
7895 
  Attributes:
4394 rajveer 7896 
   - type
4444 rajveer 7897 
   - warehouseId
4394 rajveer 7898 
   - status
7899 
   - timestamp
94 ashish 7900 
  """
7901 
 
7902 
  thrift_spec = (
7903 
    None, # 0
4394 rajveer 7904 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 7905 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7906 
    (3, TType.I64, 'status', None, None, ), # 3
7907 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 7908 
  )
7909 
 
4444 rajveer 7910 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 7911 
    self.type = type
4444 rajveer 7912 
    self.warehouseId = warehouseId
4394 rajveer 7913 
    self.status = status
7914 
    self.timestamp = timestamp
94 ashish 7915 
 
7916 
  def read(self, iprot):
7917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7919 
      return
7920 
    iprot.readStructBegin()
7921 
    while True:
7922 
      (fname, ftype, fid) = iprot.readFieldBegin()
7923 
      if ftype == TType.STOP:
7924 
        break
7925 
      if fid == 1:
3064 chandransh 7926 
        if ftype == TType.I64:
4394 rajveer 7927 
          self.type = iprot.readI64();
94 ashish 7928 
        else:
7929 
          iprot.skip(ftype)
3064 chandransh 7930 
      elif fid == 2:
4394 rajveer 7931 
        if ftype == TType.I64:
4444 rajveer 7932 
          self.warehouseId = iprot.readI64();
3064 chandransh 7933 
        else:
7934 
          iprot.skip(ftype)
4394 rajveer 7935 
      elif fid == 3:
7936 
        if ftype == TType.I64:
4444 rajveer 7937 
          self.status = iprot.readI64();
7938 
        else:
7939 
          iprot.skip(ftype)
7940 
      elif fid == 4:
7941 
        if ftype == TType.I64:
4394 rajveer 7942 
          self.timestamp = iprot.readI64();
7943 
        else:
7944 
          iprot.skip(ftype)
94 ashish 7945 
      else:
7946 
        iprot.skip(ftype)
7947 
      iprot.readFieldEnd()
7948 
    iprot.readStructEnd()
7949 
 
7950 
  def write(self, oprot):
7951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7953 
      return
3064 chandransh 7954 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 7955 
    if self.type is not None:
7956 
      oprot.writeFieldBegin('type', TType.I64, 1)
7957 
      oprot.writeI64(self.type)
94 ashish 7958 
      oprot.writeFieldEnd()
4444 rajveer 7959 
    if self.warehouseId is not None:
7960 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7961 
      oprot.writeI64(self.warehouseId)
7962 
      oprot.writeFieldEnd()
4394 rajveer 7963 
    if self.status is not None:
4444 rajveer 7964 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 7965 
      oprot.writeI64(self.status)
3064 chandransh 7966 
      oprot.writeFieldEnd()
4394 rajveer 7967 
    if self.timestamp is not None:
4444 rajveer 7968 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 7969 
      oprot.writeI64(self.timestamp)
7970 
      oprot.writeFieldEnd()
94 ashish 7971 
    oprot.writeFieldStop()
7972 
    oprot.writeStructEnd()
7973 
 
3431 rajveer 7974 
  def validate(self):
7975 
    return
7976 
 
7977 
 
94 ashish 7978 
  def __repr__(self):
7979 
    L = ['%s=%r' % (key, value)
7980 
      for key, value in self.__dict__.iteritems()]
7981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7982 
 
7983 
  def __eq__(self, other):
7984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7985 
 
7986 
  def __ne__(self, other):
7987 
    return not (self == other)
7988 
 
3064 chandransh 7989 
class getAlerts_result:
94 ashish 7990 
  """
7991 
  Attributes:
7992 
   - success
7993 
  """
7994 
 
7995 
  thrift_spec = (
3064 chandransh 7996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7997 
  )
7998 
 
3064 chandransh 7999 
  def __init__(self, success=None,):
94 ashish 8000 
    self.success = success
8001 
 
8002 
  def read(self, iprot):
8003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8005 
      return
8006 
    iprot.readStructBegin()
8007 
    while True:
8008 
      (fname, ftype, fid) = iprot.readFieldBegin()
8009 
      if ftype == TType.STOP:
8010 
        break
8011 
      if fid == 0:
3064 chandransh 8012 
        if ftype == TType.LIST:
8013 
          self.success = []
4133 chandransh 8014 
          (_etype115, _size112) = iprot.readListBegin()
8015 
          for _i116 in xrange(_size112):
8016 
            _elem117 = Alert()
8017 
            _elem117.read(iprot)
8018 
            self.success.append(_elem117)
3064 chandransh 8019 
          iprot.readListEnd()
94 ashish 8020 
        else:
8021 
          iprot.skip(ftype)
8022 
      else:
8023 
        iprot.skip(ftype)
8024 
      iprot.readFieldEnd()
8025 
    iprot.readStructEnd()
8026 
 
8027 
  def write(self, oprot):
8028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8030 
      return
3064 chandransh 8031 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8032 
    if self.success is not None:
3064 chandransh 8033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8035 
      for iter118 in self.success:
8036 
        iter118.write(oprot)
3064 chandransh 8037 
      oprot.writeListEnd()
94 ashish 8038 
      oprot.writeFieldEnd()
8039 
    oprot.writeFieldStop()
8040 
    oprot.writeStructEnd()
8041 
 
3431 rajveer 8042 
  def validate(self):
8043 
    return
8044 
 
8045 
 
94 ashish 8046 
  def __repr__(self):
8047 
    L = ['%s=%r' % (key, value)
8048 
      for key, value in self.__dict__.iteritems()]
8049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8050 
 
8051 
  def __eq__(self, other):
8052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8053 
 
8054 
  def __ne__(self, other):
8055 
    return not (self == other)
8056 
 
4394 rajveer 8057 
class addAlert_args:
94 ashish 8058 
  """
8059 
  Attributes:
3064 chandransh 8060 
   - type
4444 rajveer 8061 
   - warehouseId
4394 rajveer 8062 
   - description
94 ashish 8063 
  """
8064 
 
8065 
  thrift_spec = (
8066 
    None, # 0
4394 rajveer 8067 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8068 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8069 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8070 
  )
8071 
 
4444 rajveer 8072 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8073 
    self.type = type
4444 rajveer 8074 
    self.warehouseId = warehouseId
4394 rajveer 8075 
    self.description = description
94 ashish 8076 
 
8077 
  def read(self, iprot):
8078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8080 
      return
8081 
    iprot.readStructBegin()
8082 
    while True:
8083 
      (fname, ftype, fid) = iprot.readFieldBegin()
8084 
      if ftype == TType.STOP:
8085 
        break
8086 
      if fid == 1:
8087 
        if ftype == TType.I64:
4394 rajveer 8088 
          self.type = iprot.readI64();
94 ashish 8089 
        else:
8090 
          iprot.skip(ftype)
3064 chandransh 8091 
      elif fid == 2:
4444 rajveer 8092 
        if ftype == TType.I64:
8093 
          self.warehouseId = iprot.readI64();
8094 
        else:
8095 
          iprot.skip(ftype)
8096 
      elif fid == 3:
3064 chandransh 8097 
        if ftype == TType.STRING:
4394 rajveer 8098 
          self.description = iprot.readString();
3064 chandransh 8099 
        else:
8100 
          iprot.skip(ftype)
94 ashish 8101 
      else:
8102 
        iprot.skip(ftype)
8103 
      iprot.readFieldEnd()
8104 
    iprot.readStructEnd()
8105 
 
8106 
  def write(self, oprot):
8107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8109 
      return
4394 rajveer 8110 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8111 
    if self.type is not None:
4394 rajveer 8112 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8113 
      oprot.writeI64(self.type)
8114 
      oprot.writeFieldEnd()
4444 rajveer 8115 
    if self.warehouseId is not None:
8116 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8117 
      oprot.writeI64(self.warehouseId)
8118 
      oprot.writeFieldEnd()
4394 rajveer 8119 
    if self.description is not None:
4444 rajveer 8120 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8121 
      oprot.writeString(self.description)
3064 chandransh 8122 
      oprot.writeFieldEnd()
94 ashish 8123 
    oprot.writeFieldStop()
8124 
    oprot.writeStructEnd()
8125 
 
3431 rajveer 8126 
  def validate(self):
8127 
    return
8128 
 
8129 
 
94 ashish 8130 
  def __repr__(self):
8131 
    L = ['%s=%r' % (key, value)
8132 
      for key, value in self.__dict__.iteritems()]
8133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8134 
 
8135 
  def __eq__(self, other):
8136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8137 
 
8138 
  def __ne__(self, other):
8139 
    return not (self == other)
8140 
 
4394 rajveer 8141 
class addAlert_result:
3064 chandransh 8142 
 
8143 
  thrift_spec = (
8144 
  )
8145 
 
8146 
  def read(self, iprot):
8147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8149 
      return
8150 
    iprot.readStructBegin()
8151 
    while True:
8152 
      (fname, ftype, fid) = iprot.readFieldBegin()
8153 
      if ftype == TType.STOP:
8154 
        break
8155 
      else:
8156 
        iprot.skip(ftype)
8157 
      iprot.readFieldEnd()
8158 
    iprot.readStructEnd()
8159 
 
8160 
  def write(self, oprot):
8161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8163 
      return
4394 rajveer 8164 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8165 
    oprot.writeFieldStop()
8166 
    oprot.writeStructEnd()
8167 
 
3431 rajveer 8168 
  def validate(self):
8169 
    return
8170 
 
8171 
 
3064 chandransh 8172 
  def __repr__(self):
8173 
    L = ['%s=%r' % (key, value)
8174 
      for key, value in self.__dict__.iteritems()]
8175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8176 
 
8177 
  def __eq__(self, other):
8178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8179 
 
8180 
  def __ne__(self, other):
8181 
    return not (self == other)
8182 
 
4444 rajveer 8183 
class markAlertsAsSeen_args:
8184 
  """
8185 
  Attributes:
8186 
   - warehouseId
8187 
  """
8188 
 
8189 
  thrift_spec = (
8190 
    None, # 0
8191 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8192 
  )
8193 
 
8194 
  def __init__(self, warehouseId=None,):
8195 
    self.warehouseId = warehouseId
8196 
 
8197 
  def read(self, iprot):
8198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8200 
      return
8201 
    iprot.readStructBegin()
8202 
    while True:
8203 
      (fname, ftype, fid) = iprot.readFieldBegin()
8204 
      if ftype == TType.STOP:
8205 
        break
8206 
      if fid == 1:
8207 
        if ftype == TType.I64:
8208 
          self.warehouseId = iprot.readI64();
8209 
        else:
8210 
          iprot.skip(ftype)
8211 
      else:
8212 
        iprot.skip(ftype)
8213 
      iprot.readFieldEnd()
8214 
    iprot.readStructEnd()
8215 
 
8216 
  def write(self, oprot):
8217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8219 
      return
8220 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8221 
    if self.warehouseId is not None:
8222 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8223 
      oprot.writeI64(self.warehouseId)
8224 
      oprot.writeFieldEnd()
8225 
    oprot.writeFieldStop()
8226 
    oprot.writeStructEnd()
8227 
 
8228 
  def validate(self):
8229 
    return
8230 
 
8231 
 
8232 
  def __repr__(self):
8233 
    L = ['%s=%r' % (key, value)
8234 
      for key, value in self.__dict__.iteritems()]
8235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8236 
 
8237 
  def __eq__(self, other):
8238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8239 
 
8240 
  def __ne__(self, other):
8241 
    return not (self == other)
8242 
 
8243 
class markAlertsAsSeen_result:
8244 
 
8245 
  thrift_spec = (
8246 
  )
8247 
 
8248 
  def read(self, iprot):
8249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8251 
      return
8252 
    iprot.readStructBegin()
8253 
    while True:
8254 
      (fname, ftype, fid) = iprot.readFieldBegin()
8255 
      if ftype == TType.STOP:
8256 
        break
8257 
      else:
8258 
        iprot.skip(ftype)
8259 
      iprot.readFieldEnd()
8260 
    iprot.readStructEnd()
8261 
 
8262 
  def write(self, oprot):
8263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8265 
      return
8266 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8267 
    oprot.writeFieldStop()
8268 
    oprot.writeStructEnd()
8269 
 
8270 
  def validate(self):
8271 
    return
8272 
 
8273 
 
8274 
  def __repr__(self):
8275 
    L = ['%s=%r' % (key, value)
8276 
      for key, value in self.__dict__.iteritems()]
8277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8278 
 
8279 
  def __eq__(self, other):
8280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8281 
 
8282 
  def __ne__(self, other):
8283 
    return not (self == other)
8284 
 
3064 chandransh 8285 
class getValidOrderCount_args:
8286 
 
8287 
  thrift_spec = (
8288 
  )
8289 
 
8290 
  def read(self, iprot):
8291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8293 
      return
8294 
    iprot.readStructBegin()
8295 
    while True:
8296 
      (fname, ftype, fid) = iprot.readFieldBegin()
8297 
      if ftype == TType.STOP:
8298 
        break
8299 
      else:
8300 
        iprot.skip(ftype)
8301 
      iprot.readFieldEnd()
8302 
    iprot.readStructEnd()
8303 
 
8304 
  def write(self, oprot):
8305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8307 
      return
8308 
    oprot.writeStructBegin('getValidOrderCount_args')
8309 
    oprot.writeFieldStop()
8310 
    oprot.writeStructEnd()
8311 
 
3431 rajveer 8312 
  def validate(self):
8313 
    return
8314 
 
8315 
 
3064 chandransh 8316 
  def __repr__(self):
8317 
    L = ['%s=%r' % (key, value)
8318 
      for key, value in self.__dict__.iteritems()]
8319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8320 
 
8321 
  def __eq__(self, other):
8322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8323 
 
8324 
  def __ne__(self, other):
8325 
    return not (self == other)
8326 
 
8327 
class getValidOrderCount_result:
94 ashish 8328 
  """
8329 
  Attributes:
8330 
   - success
8331 
  """
8332 
 
8333 
  thrift_spec = (
3064 chandransh 8334 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8335 
  )
8336 
 
3064 chandransh 8337 
  def __init__(self, success=None,):
94 ashish 8338 
    self.success = success
8339 
 
8340 
  def read(self, iprot):
8341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8343 
      return
8344 
    iprot.readStructBegin()
8345 
    while True:
8346 
      (fname, ftype, fid) = iprot.readFieldBegin()
8347 
      if ftype == TType.STOP:
8348 
        break
8349 
      if fid == 0:
3064 chandransh 8350 
        if ftype == TType.I64:
8351 
          self.success = iprot.readI64();
94 ashish 8352 
        else:
8353 
          iprot.skip(ftype)
8354 
      else:
8355 
        iprot.skip(ftype)
8356 
      iprot.readFieldEnd()
8357 
    iprot.readStructEnd()
8358 
 
8359 
  def write(self, oprot):
8360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8362 
      return
3064 chandransh 8363 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8364 
    if self.success is not None:
3064 chandransh 8365 
      oprot.writeFieldBegin('success', TType.I64, 0)
8366 
      oprot.writeI64(self.success)
94 ashish 8367 
      oprot.writeFieldEnd()
8368 
    oprot.writeFieldStop()
8369 
    oprot.writeStructEnd()
8370 
 
3431 rajveer 8371 
  def validate(self):
8372 
    return
8373 
 
8374 
 
94 ashish 8375 
  def __repr__(self):
8376 
    L = ['%s=%r' % (key, value)
8377 
      for key, value in self.__dict__.iteritems()]
8378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8379 
 
8380 
  def __eq__(self, other):
8381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8382 
 
8383 
  def __ne__(self, other):
8384 
    return not (self == other)
8385 
 
3064 chandransh 8386 
class getNoOfCustomersWithSuccessfulTransaction_args:
8387 
 
8388 
  thrift_spec = (
8389 
  )
8390 
 
8391 
  def read(self, iprot):
8392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8394 
      return
8395 
    iprot.readStructBegin()
8396 
    while True:
8397 
      (fname, ftype, fid) = iprot.readFieldBegin()
8398 
      if ftype == TType.STOP:
8399 
        break
8400 
      else:
8401 
        iprot.skip(ftype)
8402 
      iprot.readFieldEnd()
8403 
    iprot.readStructEnd()
8404 
 
8405 
  def write(self, oprot):
8406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8408 
      return
8409 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8410 
    oprot.writeFieldStop()
8411 
    oprot.writeStructEnd()
8412 
 
3431 rajveer 8413 
  def validate(self):
8414 
    return
8415 
 
8416 
 
3064 chandransh 8417 
  def __repr__(self):
8418 
    L = ['%s=%r' % (key, value)
8419 
      for key, value in self.__dict__.iteritems()]
8420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8421 
 
8422 
  def __eq__(self, other):
8423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8424 
 
8425 
  def __ne__(self, other):
8426 
    return not (self == other)
8427 
 
8428 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8429 
  """
8430 
  Attributes:
3064 chandransh 8431 
   - success
94 ashish 8432 
  """
8433 
 
8434 
  thrift_spec = (
3064 chandransh 8435 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8436 
  )
8437 
 
3064 chandransh 8438 
  def __init__(self, success=None,):
8439 
    self.success = success
94 ashish 8440 
 
8441 
  def read(self, iprot):
8442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8444 
      return
8445 
    iprot.readStructBegin()
8446 
    while True:
8447 
      (fname, ftype, fid) = iprot.readFieldBegin()
8448 
      if ftype == TType.STOP:
8449 
        break
3064 chandransh 8450 
      if fid == 0:
94 ashish 8451 
        if ftype == TType.I64:
3064 chandransh 8452 
          self.success = iprot.readI64();
94 ashish 8453 
        else:
8454 
          iprot.skip(ftype)
8455 
      else:
8456 
        iprot.skip(ftype)
8457 
      iprot.readFieldEnd()
8458 
    iprot.readStructEnd()
8459 
 
8460 
  def write(self, oprot):
8461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8463 
      return
3064 chandransh 8464 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8465 
    if self.success is not None:
3064 chandransh 8466 
      oprot.writeFieldBegin('success', TType.I64, 0)
8467 
      oprot.writeI64(self.success)
94 ashish 8468 
      oprot.writeFieldEnd()
8469 
    oprot.writeFieldStop()
8470 
    oprot.writeStructEnd()
8471 
 
3431 rajveer 8472 
  def validate(self):
8473 
    return
8474 
 
8475 
 
94 ashish 8476 
  def __repr__(self):
8477 
    L = ['%s=%r' % (key, value)
8478 
      for key, value in self.__dict__.iteritems()]
8479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8480 
 
8481 
  def __eq__(self, other):
8482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8483 
 
8484 
  def __ne__(self, other):
8485 
    return not (self == other)
8486 
 
3064 chandransh 8487 
class getValidOrdersAmountRange_args:
8488 
 
8489 
  thrift_spec = (
8490 
  )
8491 
 
8492 
  def read(self, iprot):
8493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8495 
      return
8496 
    iprot.readStructBegin()
8497 
    while True:
8498 
      (fname, ftype, fid) = iprot.readFieldBegin()
8499 
      if ftype == TType.STOP:
8500 
        break
8501 
      else:
8502 
        iprot.skip(ftype)
8503 
      iprot.readFieldEnd()
8504 
    iprot.readStructEnd()
8505 
 
8506 
  def write(self, oprot):
8507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8509 
      return
8510 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8511 
    oprot.writeFieldStop()
8512 
    oprot.writeStructEnd()
8513 
 
3431 rajveer 8514 
  def validate(self):
8515 
    return
8516 
 
8517 
 
3064 chandransh 8518 
  def __repr__(self):
8519 
    L = ['%s=%r' % (key, value)
8520 
      for key, value in self.__dict__.iteritems()]
8521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8522 
 
8523 
  def __eq__(self, other):
8524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8525 
 
8526 
  def __ne__(self, other):
8527 
    return not (self == other)
8528 
 
8529 
class getValidOrdersAmountRange_result:
94 ashish 8530 
  """
8531 
  Attributes:
8532 
   - success
8533 
  """
8534 
 
8535 
  thrift_spec = (
3064 chandransh 8536 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8537 
  )
8538 
 
3064 chandransh 8539 
  def __init__(self, success=None,):
94 ashish 8540 
    self.success = success
8541 
 
8542 
  def read(self, iprot):
8543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8545 
      return
8546 
    iprot.readStructBegin()
8547 
    while True:
8548 
      (fname, ftype, fid) = iprot.readFieldBegin()
8549 
      if ftype == TType.STOP:
8550 
        break
8551 
      if fid == 0:
483 rajveer 8552 
        if ftype == TType.LIST:
8553 
          self.success = []
4133 chandransh 8554 
          (_etype122, _size119) = iprot.readListBegin()
8555 
          for _i123 in xrange(_size119):
8556 
            _elem124 = iprot.readDouble();
8557 
            self.success.append(_elem124)
483 rajveer 8558 
          iprot.readListEnd()
94 ashish 8559 
        else:
8560 
          iprot.skip(ftype)
8561 
      else:
8562 
        iprot.skip(ftype)
8563 
      iprot.readFieldEnd()
8564 
    iprot.readStructEnd()
8565 
 
8566 
  def write(self, oprot):
8567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8569 
      return
3064 chandransh 8570 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8571 
    if self.success is not None:
483 rajveer 8572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8573 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8574 
      for iter125 in self.success:
8575 
        oprot.writeDouble(iter125)
483 rajveer 8576 
      oprot.writeListEnd()
94 ashish 8577 
      oprot.writeFieldEnd()
8578 
    oprot.writeFieldStop()
8579 
    oprot.writeStructEnd()
8580 
 
3431 rajveer 8581 
  def validate(self):
8582 
    return
8583 
 
8584 
 
94 ashish 8585 
  def __repr__(self):
8586 
    L = ['%s=%r' % (key, value)
8587 
      for key, value in self.__dict__.iteritems()]
8588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8589 
 
8590 
  def __eq__(self, other):
8591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8592 
 
8593 
  def __ne__(self, other):
8594 
    return not (self == other)
8595 
 
3064 chandransh 8596 
class getValidOrders_args:
1528 ankur.sing 8597 
  """
8598 
  Attributes:
3064 chandransh 8599 
   - limit
1528 ankur.sing 8600 
  """
8601 
 
8602 
  thrift_spec = (
8603 
    None, # 0
3064 chandransh 8604 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8605 
  )
8606 
 
3064 chandransh 8607 
  def __init__(self, limit=None,):
8608 
    self.limit = limit
1528 ankur.sing 8609 
 
8610 
  def read(self, iprot):
8611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8613 
      return
8614 
    iprot.readStructBegin()
8615 
    while True:
8616 
      (fname, ftype, fid) = iprot.readFieldBegin()
8617 
      if ftype == TType.STOP:
8618 
        break
8619 
      if fid == 1:
8620 
        if ftype == TType.I64:
3064 chandransh 8621 
          self.limit = iprot.readI64();
1528 ankur.sing 8622 
        else:
8623 
          iprot.skip(ftype)
8624 
      else:
8625 
        iprot.skip(ftype)
8626 
      iprot.readFieldEnd()
8627 
    iprot.readStructEnd()
8628 
 
8629 
  def write(self, oprot):
8630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8632 
      return
3064 chandransh 8633 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8634 
    if self.limit is not None:
3064 chandransh 8635 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8636 
      oprot.writeI64(self.limit)
1528 ankur.sing 8637 
      oprot.writeFieldEnd()
8638 
    oprot.writeFieldStop()
8639 
    oprot.writeStructEnd()
8640 
 
3431 rajveer 8641 
  def validate(self):
8642 
    return
8643 
 
8644 
 
1528 ankur.sing 8645 
  def __repr__(self):
8646 
    L = ['%s=%r' % (key, value)
8647 
      for key, value in self.__dict__.iteritems()]
8648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8649 
 
8650 
  def __eq__(self, other):
8651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8652 
 
8653 
  def __ne__(self, other):
8654 
    return not (self == other)
8655 
 
3064 chandransh 8656 
class getValidOrders_result:
1528 ankur.sing 8657 
  """
8658 
  Attributes:
8659 
   - success
8660 
  """
8661 
 
8662 
  thrift_spec = (
3064 chandransh 8663 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8664 
  )
8665 
 
3064 chandransh 8666 
  def __init__(self, success=None,):
1528 ankur.sing 8667 
    self.success = success
8668 
 
8669 
  def read(self, iprot):
8670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8672 
      return
8673 
    iprot.readStructBegin()
8674 
    while True:
8675 
      (fname, ftype, fid) = iprot.readFieldBegin()
8676 
      if ftype == TType.STOP:
8677 
        break
8678 
      if fid == 0:
3064 chandransh 8679 
        if ftype == TType.LIST:
8680 
          self.success = []
4133 chandransh 8681 
          (_etype129, _size126) = iprot.readListBegin()
8682 
          for _i130 in xrange(_size126):
8683 
            _elem131 = Order()
8684 
            _elem131.read(iprot)
8685 
            self.success.append(_elem131)
3064 chandransh 8686 
          iprot.readListEnd()
1528 ankur.sing 8687 
        else:
8688 
          iprot.skip(ftype)
8689 
      else:
8690 
        iprot.skip(ftype)
8691 
      iprot.readFieldEnd()
8692 
    iprot.readStructEnd()
8693 
 
8694 
  def write(self, oprot):
8695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8697 
      return
3064 chandransh 8698 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8699 
    if self.success is not None:
3064 chandransh 8700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8702 
      for iter132 in self.success:
8703 
        iter132.write(oprot)
3064 chandransh 8704 
      oprot.writeListEnd()
1528 ankur.sing 8705 
      oprot.writeFieldEnd()
8706 
    oprot.writeFieldStop()
8707 
    oprot.writeStructEnd()
8708 
 
3431 rajveer 8709 
  def validate(self):
8710 
    return
8711 
 
8712 
 
1528 ankur.sing 8713 
  def __repr__(self):
8714 
    L = ['%s=%r' % (key, value)
8715 
      for key, value in self.__dict__.iteritems()]
8716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8717 
 
8718 
  def __eq__(self, other):
8719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8720 
 
8721 
  def __ne__(self, other):
8722 
    return not (self == other)
8723 
 
1220 chandransh 8724 
class batchOrders_args:
8725 
  """
8726 
  Attributes:
8727 
   - warehouseId
8728 
  """
8729 
 
8730 
  thrift_spec = (
8731 
    None, # 0
8732 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8733 
  )
8734 
 
8735 
  def __init__(self, warehouseId=None,):
8736 
    self.warehouseId = warehouseId
8737 
 
8738 
  def read(self, iprot):
8739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8741 
      return
8742 
    iprot.readStructBegin()
8743 
    while True:
8744 
      (fname, ftype, fid) = iprot.readFieldBegin()
8745 
      if ftype == TType.STOP:
8746 
        break
8747 
      if fid == 1:
8748 
        if ftype == TType.I64:
8749 
          self.warehouseId = iprot.readI64();
8750 
        else:
8751 
          iprot.skip(ftype)
8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
8761 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8762 
    if self.warehouseId is not None:
1220 chandransh 8763 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8764 
      oprot.writeI64(self.warehouseId)
8765 
      oprot.writeFieldEnd()
8766 
    oprot.writeFieldStop()
8767 
    oprot.writeStructEnd()
8768 
 
3431 rajveer 8769 
  def validate(self):
8770 
    return
8771 
 
8772 
 
1220 chandransh 8773 
  def __repr__(self):
8774 
    L = ['%s=%r' % (key, value)
8775 
      for key, value in self.__dict__.iteritems()]
8776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8777 
 
8778 
  def __eq__(self, other):
8779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8780 
 
8781 
  def __ne__(self, other):
8782 
    return not (self == other)
8783 
 
8784 
class batchOrders_result:
8785 
  """
8786 
  Attributes:
8787 
   - success
8788 
   - ex
8789 
  """
8790 
 
8791 
  thrift_spec = (
8792 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8794 
  )
8795 
 
8796 
  def __init__(self, success=None, ex=None,):
8797 
    self.success = success
8798 
    self.ex = ex
8799 
 
8800 
  def read(self, iprot):
8801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8803 
      return
8804 
    iprot.readStructBegin()
8805 
    while True:
8806 
      (fname, ftype, fid) = iprot.readFieldBegin()
8807 
      if ftype == TType.STOP:
8808 
        break
8809 
      if fid == 0:
8810 
        if ftype == TType.LIST:
8811 
          self.success = []
4133 chandransh 8812 
          (_etype136, _size133) = iprot.readListBegin()
8813 
          for _i137 in xrange(_size133):
8814 
            _elem138 = Order()
8815 
            _elem138.read(iprot)
8816 
            self.success.append(_elem138)
1220 chandransh 8817 
          iprot.readListEnd()
8818 
        else:
8819 
          iprot.skip(ftype)
8820 
      elif fid == 1:
8821 
        if ftype == TType.STRUCT:
8822 
          self.ex = TransactionServiceException()
8823 
          self.ex.read(iprot)
8824 
        else:
8825 
          iprot.skip(ftype)
8826 
      else:
8827 
        iprot.skip(ftype)
8828 
      iprot.readFieldEnd()
8829 
    iprot.readStructEnd()
8830 
 
8831 
  def write(self, oprot):
8832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8834 
      return
8835 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8836 
    if self.success is not None:
1220 chandransh 8837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8839 
      for iter139 in self.success:
8840 
        iter139.write(oprot)
1220 chandransh 8841 
      oprot.writeListEnd()
8842 
      oprot.writeFieldEnd()
3431 rajveer 8843 
    if self.ex is not None:
1220 chandransh 8844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8845 
      self.ex.write(oprot)
8846 
      oprot.writeFieldEnd()
8847 
    oprot.writeFieldStop()
8848 
    oprot.writeStructEnd()
8849 
 
3431 rajveer 8850 
  def validate(self):
8851 
    return
8852 
 
8853 
 
1220 chandransh 8854 
  def __repr__(self):
8855 
    L = ['%s=%r' % (key, value)
8856 
      for key, value in self.__dict__.iteritems()]
8857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8858 
 
8859 
  def __eq__(self, other):
8860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8861 
 
8862 
  def __ne__(self, other):
8863 
    return not (self == other)
8864 
 
1208 chandransh 8865 
class markOrderAsOutOfStock_args:
8866 
  """
8867 
  Attributes:
8868 
   - orderId
8869 
  """
8870 
 
8871 
  thrift_spec = (
8872 
    None, # 0
8873 
    (1, TType.I64, 'orderId', None, None, ), # 1
8874 
  )
8875 
 
8876 
  def __init__(self, orderId=None,):
8877 
    self.orderId = orderId
8878 
 
8879 
  def read(self, iprot):
8880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8882 
      return
8883 
    iprot.readStructBegin()
8884 
    while True:
8885 
      (fname, ftype, fid) = iprot.readFieldBegin()
8886 
      if ftype == TType.STOP:
8887 
        break
8888 
      if fid == 1:
8889 
        if ftype == TType.I64:
8890 
          self.orderId = iprot.readI64();
8891 
        else:
8892 
          iprot.skip(ftype)
8893 
      else:
8894 
        iprot.skip(ftype)
8895 
      iprot.readFieldEnd()
8896 
    iprot.readStructEnd()
8897 
 
8898 
  def write(self, oprot):
8899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8901 
      return
8902 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8903 
    if self.orderId is not None:
1208 chandransh 8904 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8905 
      oprot.writeI64(self.orderId)
8906 
      oprot.writeFieldEnd()
8907 
    oprot.writeFieldStop()
8908 
    oprot.writeStructEnd()
8909 
 
3431 rajveer 8910 
  def validate(self):
8911 
    return
8912 
 
8913 
 
1208 chandransh 8914 
  def __repr__(self):
8915 
    L = ['%s=%r' % (key, value)
8916 
      for key, value in self.__dict__.iteritems()]
8917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8918 
 
8919 
  def __eq__(self, other):
8920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8921 
 
8922 
  def __ne__(self, other):
8923 
    return not (self == other)
8924 
 
8925 
class markOrderAsOutOfStock_result:
8926 
  """
8927 
  Attributes:
8928 
   - success
8929 
   - ex
8930 
  """
8931 
 
8932 
  thrift_spec = (
8933 
    (0, TType.BOOL, 'success', None, None, ), # 0
8934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8935 
  )
8936 
 
8937 
  def __init__(self, success=None, ex=None,):
8938 
    self.success = success
8939 
    self.ex = ex
8940 
 
8941 
  def read(self, iprot):
8942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8944 
      return
8945 
    iprot.readStructBegin()
8946 
    while True:
8947 
      (fname, ftype, fid) = iprot.readFieldBegin()
8948 
      if ftype == TType.STOP:
8949 
        break
8950 
      if fid == 0:
8951 
        if ftype == TType.BOOL:
8952 
          self.success = iprot.readBool();
8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      elif fid == 1:
8956 
        if ftype == TType.STRUCT:
8957 
          self.ex = TransactionServiceException()
8958 
          self.ex.read(iprot)
8959 
        else:
8960 
          iprot.skip(ftype)
8961 
      else:
8962 
        iprot.skip(ftype)
8963 
      iprot.readFieldEnd()
8964 
    iprot.readStructEnd()
8965 
 
8966 
  def write(self, oprot):
8967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8969 
      return
8970 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8971 
    if self.success is not None:
1208 chandransh 8972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8973 
      oprot.writeBool(self.success)
8974 
      oprot.writeFieldEnd()
3431 rajveer 8975 
    if self.ex is not None:
1208 chandransh 8976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8977 
      self.ex.write(oprot)
8978 
      oprot.writeFieldEnd()
8979 
    oprot.writeFieldStop()
8980 
    oprot.writeStructEnd()
8981 
 
3431 rajveer 8982 
  def validate(self):
8983 
    return
8984 
 
8985 
 
1208 chandransh 8986 
  def __repr__(self):
8987 
    L = ['%s=%r' % (key, value)
8988 
      for key, value in self.__dict__.iteritems()]
8989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8990 
 
8991 
  def __eq__(self, other):
8992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8993 
 
8994 
  def __ne__(self, other):
8995 
    return not (self == other)
8996 
 
3064 chandransh 8997 
class verifyOrder_args:
759 chandransh 8998 
  """
8999 
  Attributes:
3064 chandransh 9000 
   - orderId
759 chandransh 9001 
  """
9002 
 
9003 
  thrift_spec = (
9004 
    None, # 0
3064 chandransh 9005 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9006 
  )
9007 
 
3064 chandransh 9008 
  def __init__(self, orderId=None,):
9009 
    self.orderId = orderId
759 chandransh 9010 
 
9011 
  def read(self, iprot):
9012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9014 
      return
9015 
    iprot.readStructBegin()
9016 
    while True:
9017 
      (fname, ftype, fid) = iprot.readFieldBegin()
9018 
      if ftype == TType.STOP:
9019 
        break
9020 
      if fid == 1:
9021 
        if ftype == TType.I64:
3064 chandransh 9022 
          self.orderId = iprot.readI64();
759 chandransh 9023 
        else:
9024 
          iprot.skip(ftype)
9025 
      else:
9026 
        iprot.skip(ftype)
9027 
      iprot.readFieldEnd()
9028 
    iprot.readStructEnd()
9029 
 
9030 
  def write(self, oprot):
9031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9033 
      return
3064 chandransh 9034 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9035 
    if self.orderId is not None:
3064 chandransh 9036 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9037 
      oprot.writeI64(self.orderId)
759 chandransh 9038 
      oprot.writeFieldEnd()
9039 
    oprot.writeFieldStop()
9040 
    oprot.writeStructEnd()
9041 
 
3431 rajveer 9042 
  def validate(self):
9043 
    return
9044 
 
9045 
 
759 chandransh 9046 
  def __repr__(self):
9047 
    L = ['%s=%r' % (key, value)
9048 
      for key, value in self.__dict__.iteritems()]
9049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9050 
 
9051 
  def __eq__(self, other):
9052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9053 
 
9054 
  def __ne__(self, other):
9055 
    return not (self == other)
9056 
 
3064 chandransh 9057 
class verifyOrder_result:
759 chandransh 9058 
  """
9059 
  Attributes:
9060 
   - success
9061 
   - ex
9062 
  """
9063 
 
9064 
  thrift_spec = (
9065 
    (0, TType.BOOL, 'success', None, None, ), # 0
9066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9067 
  )
9068 
 
9069 
  def __init__(self, success=None, ex=None,):
9070 
    self.success = success
9071 
    self.ex = ex
9072 
 
9073 
  def read(self, iprot):
9074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9076 
      return
9077 
    iprot.readStructBegin()
9078 
    while True:
9079 
      (fname, ftype, fid) = iprot.readFieldBegin()
9080 
      if ftype == TType.STOP:
9081 
        break
9082 
      if fid == 0:
9083 
        if ftype == TType.BOOL:
9084 
          self.success = iprot.readBool();
9085 
        else:
9086 
          iprot.skip(ftype)
9087 
      elif fid == 1:
9088 
        if ftype == TType.STRUCT:
9089 
          self.ex = TransactionServiceException()
9090 
          self.ex.read(iprot)
9091 
        else:
9092 
          iprot.skip(ftype)
9093 
      else:
9094 
        iprot.skip(ftype)
9095 
      iprot.readFieldEnd()
9096 
    iprot.readStructEnd()
9097 
 
9098 
  def write(self, oprot):
9099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9101 
      return
3064 chandransh 9102 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9103 
    if self.success is not None:
759 chandransh 9104 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9105 
      oprot.writeBool(self.success)
9106 
      oprot.writeFieldEnd()
3431 rajveer 9107 
    if self.ex is not None:
759 chandransh 9108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9109 
      self.ex.write(oprot)
9110 
      oprot.writeFieldEnd()
9111 
    oprot.writeFieldStop()
9112 
    oprot.writeStructEnd()
9113 
 
3431 rajveer 9114 
  def validate(self):
9115 
    return
9116 
 
9117 
 
759 chandransh 9118 
  def __repr__(self):
9119 
    L = ['%s=%r' % (key, value)
9120 
      for key, value in self.__dict__.iteritems()]
9121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9122 
 
9123 
  def __eq__(self, other):
9124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9125 
 
9126 
  def __ne__(self, other):
9127 
    return not (self == other)
9128 
 
3064 chandransh 9129 
class acceptOrder_args:
1113 chandransh 9130 
  """
9131 
  Attributes:
3064 chandransh 9132 
   - orderId
1113 chandransh 9133 
  """
9134 
 
9135 
  thrift_spec = (
9136 
    None, # 0
3064 chandransh 9137 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9138 
  )
9139 
 
3064 chandransh 9140 
  def __init__(self, orderId=None,):
9141 
    self.orderId = orderId
1113 chandransh 9142 
 
9143 
  def read(self, iprot):
9144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9146 
      return
9147 
    iprot.readStructBegin()
9148 
    while True:
9149 
      (fname, ftype, fid) = iprot.readFieldBegin()
9150 
      if ftype == TType.STOP:
9151 
        break
9152 
      if fid == 1:
9153 
        if ftype == TType.I64:
3064 chandransh 9154 
          self.orderId = iprot.readI64();
1113 chandransh 9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      else:
9158 
        iprot.skip(ftype)
9159 
      iprot.readFieldEnd()
9160 
    iprot.readStructEnd()
9161 
 
9162 
  def write(self, oprot):
9163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9165 
      return
3064 chandransh 9166 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9167 
    if self.orderId is not None:
3064 chandransh 9168 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9169 
      oprot.writeI64(self.orderId)
1113 chandransh 9170 
      oprot.writeFieldEnd()
9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
3431 rajveer 9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
1113 chandransh 9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
3064 chandransh 9189 
class acceptOrder_result:
1113 chandransh 9190 
  """
9191 
  Attributes:
9192 
   - success
9193 
   - ex
9194 
  """
9195 
 
9196 
  thrift_spec = (
3064 chandransh 9197 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9199 
  )
9200 
 
9201 
  def __init__(self, success=None, ex=None,):
9202 
    self.success = success
9203 
    self.ex = ex
9204 
 
9205 
  def read(self, iprot):
9206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9208 
      return
9209 
    iprot.readStructBegin()
9210 
    while True:
9211 
      (fname, ftype, fid) = iprot.readFieldBegin()
9212 
      if ftype == TType.STOP:
9213 
        break
9214 
      if fid == 0:
3064 chandransh 9215 
        if ftype == TType.BOOL:
9216 
          self.success = iprot.readBool();
1113 chandransh 9217 
        else:
9218 
          iprot.skip(ftype)
9219 
      elif fid == 1:
9220 
        if ftype == TType.STRUCT:
9221 
          self.ex = TransactionServiceException()
9222 
          self.ex.read(iprot)
9223 
        else:
9224 
          iprot.skip(ftype)
9225 
      else:
9226 
        iprot.skip(ftype)
9227 
      iprot.readFieldEnd()
9228 
    iprot.readStructEnd()
9229 
 
9230 
  def write(self, oprot):
9231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9233 
      return
3064 chandransh 9234 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9235 
    if self.success is not None:
3064 chandransh 9236 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9237 
      oprot.writeBool(self.success)
1113 chandransh 9238 
      oprot.writeFieldEnd()
3431 rajveer 9239 
    if self.ex is not None:
1113 chandransh 9240 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9241 
      self.ex.write(oprot)
9242 
      oprot.writeFieldEnd()
9243 
    oprot.writeFieldStop()
9244 
    oprot.writeStructEnd()
9245 
 
3431 rajveer 9246 
  def validate(self):
9247 
    return
9248 
 
9249 
 
1113 chandransh 9250 
  def __repr__(self):
9251 
    L = ['%s=%r' % (key, value)
9252 
      for key, value in self.__dict__.iteritems()]
9253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9254 
 
9255 
  def __eq__(self, other):
9256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9257 
 
9258 
  def __ne__(self, other):
9259 
    return not (self == other)
9260 
 
3064 chandransh 9261 
class addBillingDetails_args:
1135 chandransh 9262 
  """
9263 
  Attributes:
3064 chandransh 9264 
   - orderId
9265 
   - invoice_number
4283 anupam.sin 9266 
   - imeiNumber
9267 
   - itemNumber
3064 chandransh 9268 
   - billed_by
4264 rajveer 9269 
   - jacketNumber
4283 anupam.sin 9270 
   - billingType
9271 
   - vendorId
1135 chandransh 9272 
  """
9273 
 
9274 
  thrift_spec = (
9275 
    None, # 0
3064 chandransh 9276 
    (1, TType.I64, 'orderId', None, None, ), # 1
9277 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9278 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9279 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9280 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9281 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9282 
    (7, TType.I64, 'billingType', None, None, ), # 7
9283 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9284 
  )
9285 
 
4283 anupam.sin 9286 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9287 
    self.orderId = orderId
9288 
    self.invoice_number = invoice_number
4283 anupam.sin 9289 
    self.imeiNumber = imeiNumber
9290 
    self.itemNumber = itemNumber
3064 chandransh 9291 
    self.billed_by = billed_by
4264 rajveer 9292 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9293 
    self.billingType = billingType
9294 
    self.vendorId = vendorId
1135 chandransh 9295 
 
9296 
  def read(self, iprot):
9297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9299 
      return
9300 
    iprot.readStructBegin()
9301 
    while True:
9302 
      (fname, ftype, fid) = iprot.readFieldBegin()
9303 
      if ftype == TType.STOP:
9304 
        break
9305 
      if fid == 1:
9306 
        if ftype == TType.I64:
3064 chandransh 9307 
          self.orderId = iprot.readI64();
1135 chandransh 9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      elif fid == 2:
3064 chandransh 9311 
        if ftype == TType.STRING:
9312 
          self.invoice_number = iprot.readString();
1135 chandransh 9313 
        else:
9314 
          iprot.skip(ftype)
3064 chandransh 9315 
      elif fid == 3:
4264 rajveer 9316 
        if ftype == TType.I64:
3064 chandransh 9317 
          self.imeiNumber = iprot.readI64();
9318 
        else:
9319 
          iprot.skip(ftype)
9320 
      elif fid == 4:
9321 
        if ftype == TType.STRING:
9322 
          self.itemNumber = iprot.readString();
9323 
        else:
9324 
          iprot.skip(ftype)
9325 
      elif fid == 5:
9326 
        if ftype == TType.STRING:
4283 anupam.sin 9327 
          self.billed_by = iprot.readString();
3064 chandransh 9328 
        else:
9329 
          iprot.skip(ftype)
9330 
      elif fid == 6:
9331 
        if ftype == TType.I64:
4283 anupam.sin 9332 
          self.jacketNumber = iprot.readI64();
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      elif fid == 7:
9336 
        if ftype == TType.I64:
3064 chandransh 9337 
          self.billingType = iprot.readI64();
9338 
        else:
9339 
          iprot.skip(ftype)
4283 anupam.sin 9340 
      elif fid == 8:
9341 
        if ftype == TType.I64:
9342 
          self.vendorId = iprot.readI64();
9343 
        else:
9344 
          iprot.skip(ftype)
1246 chandransh 9345 
      else:
9346 
        iprot.skip(ftype)
9347 
      iprot.readFieldEnd()
9348 
    iprot.readStructEnd()
9349 
 
9350 
  def write(self, oprot):
9351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9353 
      return
4283 anupam.sin 9354 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9355 
    if self.orderId is not None:
3064 chandransh 9356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9357 
      oprot.writeI64(self.orderId)
1246 chandransh 9358 
      oprot.writeFieldEnd()
4283 anupam.sin 9359 
    if self.invoice_number is not None:
9360 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9361 
      oprot.writeString(self.invoice_number)
1246 chandransh 9362 
      oprot.writeFieldEnd()
3431 rajveer 9363 
    if self.imeiNumber is not None:
3064 chandransh 9364 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9365 
      oprot.writeI64(self.imeiNumber)
9366 
      oprot.writeFieldEnd()
3431 rajveer 9367 
    if self.itemNumber is not None:
3064 chandransh 9368 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9369 
      oprot.writeString(self.itemNumber)
9370 
      oprot.writeFieldEnd()
4283 anupam.sin 9371 
    if self.billed_by is not None:
9372 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9373 
      oprot.writeString(self.billed_by)
3064 chandransh 9374 
      oprot.writeFieldEnd()
4283 anupam.sin 9375 
    if self.jacketNumber is not None:
9376 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9377 
      oprot.writeI64(self.jacketNumber)
9378 
      oprot.writeFieldEnd()
3431 rajveer 9379 
    if self.billingType is not None:
4283 anupam.sin 9380 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9381 
      oprot.writeI64(self.billingType)
9382 
      oprot.writeFieldEnd()
4283 anupam.sin 9383 
    if self.vendorId is not None:
9384 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9385 
      oprot.writeI64(self.vendorId)
9386 
      oprot.writeFieldEnd()
1246 chandransh 9387 
    oprot.writeFieldStop()
9388 
    oprot.writeStructEnd()
9389 
 
3431 rajveer 9390 
  def validate(self):
9391 
    return
9392 
 
9393 
 
1246 chandransh 9394 
  def __repr__(self):
9395 
    L = ['%s=%r' % (key, value)
9396 
      for key, value in self.__dict__.iteritems()]
9397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9398 
 
9399 
  def __eq__(self, other):
9400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9401 
 
9402 
  def __ne__(self, other):
9403 
    return not (self == other)
9404 
 
4283 anupam.sin 9405 
class addBillingDetails_result:
1246 chandransh 9406 
  """
9407 
  Attributes:
3064 chandransh 9408 
   - success
1246 chandransh 9409 
   - ex
9410 
  """
9411 
 
9412 
  thrift_spec = (
3064 chandransh 9413 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9415 
  )
9416 
 
3064 chandransh 9417 
  def __init__(self, success=None, ex=None,):
9418 
    self.success = success
1246 chandransh 9419 
    self.ex = ex
9420 
 
9421 
  def read(self, iprot):
9422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9424 
      return
9425 
    iprot.readStructBegin()
9426 
    while True:
9427 
      (fname, ftype, fid) = iprot.readFieldBegin()
9428 
      if ftype == TType.STOP:
9429 
        break
3064 chandransh 9430 
      if fid == 0:
9431 
        if ftype == TType.BOOL:
9432 
          self.success = iprot.readBool();
9433 
        else:
9434 
          iprot.skip(ftype)
9435 
      elif fid == 1:
1246 chandransh 9436 
        if ftype == TType.STRUCT:
9437 
          self.ex = TransactionServiceException()
9438 
          self.ex.read(iprot)
9439 
        else:
9440 
          iprot.skip(ftype)
9441 
      else:
9442 
        iprot.skip(ftype)
9443 
      iprot.readFieldEnd()
9444 
    iprot.readStructEnd()
9445 
 
9446 
  def write(self, oprot):
9447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9449 
      return
4283 anupam.sin 9450 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9451 
    if self.success is not None:
3064 chandransh 9452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9453 
      oprot.writeBool(self.success)
9454 
      oprot.writeFieldEnd()
3431 rajveer 9455 
    if self.ex is not None:
1246 chandransh 9456 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9457 
      self.ex.write(oprot)
9458 
      oprot.writeFieldEnd()
9459 
    oprot.writeFieldStop()
9460 
    oprot.writeStructEnd()
9461 
 
3431 rajveer 9462 
  def validate(self):
9463 
    return
9464 
 
9465 
 
1246 chandransh 9466 
  def __repr__(self):
9467 
    L = ['%s=%r' % (key, value)
9468 
      for key, value in self.__dict__.iteritems()]
9469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9470 
 
9471 
  def __eq__(self, other):
9472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9473 
 
9474 
  def __ne__(self, other):
9475 
    return not (self == other)
9476 
 
3064 chandransh 9477 
class markOrdersAsManifested_args:
1408 ankur.sing 9478 
  """
9479 
  Attributes:
3064 chandransh 9480 
   - warehouseId
1408 ankur.sing 9481 
   - providerId
3064 chandransh 9482 
   - cod
1408 ankur.sing 9483 
  """
9484 
 
9485 
  thrift_spec = (
9486 
    None, # 0
3064 chandransh 9487 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9488 
    (2, TType.I64, 'providerId', None, None, ), # 2
9489 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9490 
  )
9491 
 
3064 chandransh 9492 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9493 
    self.warehouseId = warehouseId
1408 ankur.sing 9494 
    self.providerId = providerId
3064 chandransh 9495 
    self.cod = cod
1408 ankur.sing 9496 
 
9497 
  def read(self, iprot):
9498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9500 
      return
9501 
    iprot.readStructBegin()
9502 
    while True:
9503 
      (fname, ftype, fid) = iprot.readFieldBegin()
9504 
      if ftype == TType.STOP:
9505 
        break
9506 
      if fid == 1:
9507 
        if ftype == TType.I64:
3064 chandransh 9508 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9509 
        else:
9510 
          iprot.skip(ftype)
9511 
      elif fid == 2:
9512 
        if ftype == TType.I64:
3064 chandransh 9513 
          self.providerId = iprot.readI64();
1408 ankur.sing 9514 
        else:
9515 
          iprot.skip(ftype)
3064 chandransh 9516 
      elif fid == 3:
9517 
        if ftype == TType.BOOL:
9518 
          self.cod = iprot.readBool();
9519 
        else:
9520 
          iprot.skip(ftype)
1408 ankur.sing 9521 
      else:
9522 
        iprot.skip(ftype)
9523 
      iprot.readFieldEnd()
9524 
    iprot.readStructEnd()
9525 
 
9526 
  def write(self, oprot):
9527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9529 
      return
3064 chandransh 9530 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9531 
    if self.warehouseId is not None:
3064 chandransh 9532 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9533 
      oprot.writeI64(self.warehouseId)
9534 
      oprot.writeFieldEnd()
3431 rajveer 9535 
    if self.providerId is not None:
3064 chandransh 9536 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9537 
      oprot.writeI64(self.providerId)
9538 
      oprot.writeFieldEnd()
3431 rajveer 9539 
    if self.cod is not None:
3064 chandransh 9540 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9541 
      oprot.writeBool(self.cod)
1408 ankur.sing 9542 
      oprot.writeFieldEnd()
9543 
    oprot.writeFieldStop()
9544 
    oprot.writeStructEnd()
9545 
 
3431 rajveer 9546 
  def validate(self):
9547 
    return
9548 
 
9549 
 
1408 ankur.sing 9550 
  def __repr__(self):
9551 
    L = ['%s=%r' % (key, value)
9552 
      for key, value in self.__dict__.iteritems()]
9553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9554 
 
9555 
  def __eq__(self, other):
9556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9557 
 
9558 
  def __ne__(self, other):
9559 
    return not (self == other)
9560 
 
3064 chandransh 9561 
class markOrdersAsManifested_result:
1408 ankur.sing 9562 
  """
9563 
  Attributes:
9564 
   - success
3064 chandransh 9565 
   - ex
1408 ankur.sing 9566 
  """
9567 
 
9568 
  thrift_spec = (
3064 chandransh 9569 
    (0, TType.BOOL, 'success', None, None, ), # 0
9570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9571 
  )
9572 
 
3064 chandransh 9573 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9574 
    self.success = success
3064 chandransh 9575 
    self.ex = ex
1408 ankur.sing 9576 
 
9577 
  def read(self, iprot):
9578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9580 
      return
9581 
    iprot.readStructBegin()
9582 
    while True:
9583 
      (fname, ftype, fid) = iprot.readFieldBegin()
9584 
      if ftype == TType.STOP:
9585 
        break
9586 
      if fid == 0:
3064 chandransh 9587 
        if ftype == TType.BOOL:
9588 
          self.success = iprot.readBool();
1408 ankur.sing 9589 
        else:
9590 
          iprot.skip(ftype)
3064 chandransh 9591 
      elif fid == 1:
9592 
        if ftype == TType.STRUCT:
9593 
          self.ex = TransactionServiceException()
9594 
          self.ex.read(iprot)
9595 
        else:
9596 
          iprot.skip(ftype)
1408 ankur.sing 9597 
      else:
9598 
        iprot.skip(ftype)
9599 
      iprot.readFieldEnd()
9600 
    iprot.readStructEnd()
9601 
 
9602 
  def write(self, oprot):
9603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9605 
      return
3064 chandransh 9606 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9607 
    if self.success is not None:
3064 chandransh 9608 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9609 
      oprot.writeBool(self.success)
1408 ankur.sing 9610 
      oprot.writeFieldEnd()
3431 rajveer 9611 
    if self.ex is not None:
3064 chandransh 9612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9613 
      self.ex.write(oprot)
9614 
      oprot.writeFieldEnd()
1408 ankur.sing 9615 
    oprot.writeFieldStop()
9616 
    oprot.writeStructEnd()
9617 
 
3431 rajveer 9618 
  def validate(self):
9619 
    return
9620 
 
9621 
 
1408 ankur.sing 9622 
  def __repr__(self):
9623 
    L = ['%s=%r' % (key, value)
9624 
      for key, value in self.__dict__.iteritems()]
9625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9626 
 
9627 
  def __eq__(self, other):
9628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9629 
 
9630 
  def __ne__(self, other):
9631 
    return not (self == other)
9632 
 
4410 rajveer 9633 
class markOrdersAsShippedFromWarehouse_args:
9634 
  """
9635 
  Attributes:
9636 
   - warehouseId
9637 
   - providerId
9638 
   - cod
9639 
  """
9640 
 
9641 
  thrift_spec = (
9642 
    None, # 0
9643 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9644 
    (2, TType.I64, 'providerId', None, None, ), # 2
9645 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9646 
  )
9647 
 
9648 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9649 
    self.warehouseId = warehouseId
9650 
    self.providerId = providerId
9651 
    self.cod = cod
9652 
 
9653 
  def read(self, iprot):
9654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9656 
      return
9657 
    iprot.readStructBegin()
9658 
    while True:
9659 
      (fname, ftype, fid) = iprot.readFieldBegin()
9660 
      if ftype == TType.STOP:
9661 
        break
9662 
      if fid == 1:
9663 
        if ftype == TType.I64:
9664 
          self.warehouseId = iprot.readI64();
9665 
        else:
9666 
          iprot.skip(ftype)
9667 
      elif fid == 2:
9668 
        if ftype == TType.I64:
9669 
          self.providerId = iprot.readI64();
9670 
        else:
9671 
          iprot.skip(ftype)
9672 
      elif fid == 3:
9673 
        if ftype == TType.BOOL:
9674 
          self.cod = iprot.readBool();
9675 
        else:
9676 
          iprot.skip(ftype)
9677 
      else:
9678 
        iprot.skip(ftype)
9679 
      iprot.readFieldEnd()
9680 
    iprot.readStructEnd()
9681 
 
9682 
  def write(self, oprot):
9683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9685 
      return
9686 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9687 
    if self.warehouseId is not None:
9688 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9689 
      oprot.writeI64(self.warehouseId)
9690 
      oprot.writeFieldEnd()
9691 
    if self.providerId is not None:
9692 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9693 
      oprot.writeI64(self.providerId)
9694 
      oprot.writeFieldEnd()
9695 
    if self.cod is not None:
9696 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9697 
      oprot.writeBool(self.cod)
9698 
      oprot.writeFieldEnd()
9699 
    oprot.writeFieldStop()
9700 
    oprot.writeStructEnd()
9701 
 
9702 
  def validate(self):
9703 
    return
9704 
 
9705 
 
9706 
  def __repr__(self):
9707 
    L = ['%s=%r' % (key, value)
9708 
      for key, value in self.__dict__.iteritems()]
9709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9710 
 
9711 
  def __eq__(self, other):
9712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9713 
 
9714 
  def __ne__(self, other):
9715 
    return not (self == other)
9716 
 
9717 
class markOrdersAsShippedFromWarehouse_result:
9718 
  """
9719 
  Attributes:
9720 
   - success
9721 
   - ex
9722 
  """
9723 
 
9724 
  thrift_spec = (
9725 
    (0, TType.BOOL, 'success', None, None, ), # 0
9726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9727 
  )
9728 
 
9729 
  def __init__(self, success=None, ex=None,):
9730 
    self.success = success
9731 
    self.ex = ex
9732 
 
9733 
  def read(self, iprot):
9734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9736 
      return
9737 
    iprot.readStructBegin()
9738 
    while True:
9739 
      (fname, ftype, fid) = iprot.readFieldBegin()
9740 
      if ftype == TType.STOP:
9741 
        break
9742 
      if fid == 0:
9743 
        if ftype == TType.BOOL:
9744 
          self.success = iprot.readBool();
9745 
        else:
9746 
          iprot.skip(ftype)
9747 
      elif fid == 1:
9748 
        if ftype == TType.STRUCT:
9749 
          self.ex = TransactionServiceException()
9750 
          self.ex.read(iprot)
9751 
        else:
9752 
          iprot.skip(ftype)
9753 
      else:
9754 
        iprot.skip(ftype)
9755 
      iprot.readFieldEnd()
9756 
    iprot.readStructEnd()
9757 
 
9758 
  def write(self, oprot):
9759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9761 
      return
9762 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
9763 
    if self.success is not None:
9764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9765 
      oprot.writeBool(self.success)
9766 
      oprot.writeFieldEnd()
9767 
    if self.ex is not None:
9768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9769 
      self.ex.write(oprot)
9770 
      oprot.writeFieldEnd()
9771 
    oprot.writeFieldStop()
9772 
    oprot.writeStructEnd()
9773 
 
9774 
  def validate(self):
9775 
    return
9776 
 
9777 
 
9778 
  def __repr__(self):
9779 
    L = ['%s=%r' % (key, value)
9780 
      for key, value in self.__dict__.iteritems()]
9781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9782 
 
9783 
  def __eq__(self, other):
9784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9785 
 
9786 
  def __ne__(self, other):
9787 
    return not (self == other)
9788 
 
3064 chandransh 9789 
class markOrdersAsPickedUp_args:
304 ashish 9790 
  """
9791 
  Attributes:
3064 chandransh 9792 
   - providerId
9793 
   - pickupDetails
304 ashish 9794 
  """
94 ashish 9795 
 
304 ashish 9796 
  thrift_spec = (
9797 
    None, # 0
3064 chandransh 9798 
    (1, TType.I64, 'providerId', None, None, ), # 1
9799 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9800 
  )
9801 
 
3064 chandransh 9802 
  def __init__(self, providerId=None, pickupDetails=None,):
9803 
    self.providerId = providerId
9804 
    self.pickupDetails = pickupDetails
304 ashish 9805 
 
9806 
  def read(self, iprot):
9807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9809 
      return
9810 
    iprot.readStructBegin()
9811 
    while True:
9812 
      (fname, ftype, fid) = iprot.readFieldBegin()
9813 
      if ftype == TType.STOP:
9814 
        break
9815 
      if fid == 1:
9816 
        if ftype == TType.I64:
3064 chandransh 9817 
          self.providerId = iprot.readI64();
304 ashish 9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      elif fid == 2:
3064 chandransh 9821 
        if ftype == TType.MAP:
9822 
          self.pickupDetails = {}
4133 chandransh 9823 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9824 
          for _i144 in xrange(_size140):
9825 
            _key145 = iprot.readString();
9826 
            _val146 = iprot.readString();
9827 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9828 
          iprot.readMapEnd()
304 ashish 9829 
        else:
9830 
          iprot.skip(ftype)
9831 
      else:
9832 
        iprot.skip(ftype)
9833 
      iprot.readFieldEnd()
9834 
    iprot.readStructEnd()
9835 
 
9836 
  def write(self, oprot):
9837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9839 
      return
3064 chandransh 9840 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9841 
    if self.providerId is not None:
3064 chandransh 9842 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9843 
      oprot.writeI64(self.providerId)
304 ashish 9844 
      oprot.writeFieldEnd()
3431 rajveer 9845 
    if self.pickupDetails is not None:
3064 chandransh 9846 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9847 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9848 
      for kiter147,viter148 in self.pickupDetails.items():
9849 
        oprot.writeString(kiter147)
9850 
        oprot.writeString(viter148)
3064 chandransh 9851 
      oprot.writeMapEnd()
304 ashish 9852 
      oprot.writeFieldEnd()
9853 
    oprot.writeFieldStop()
9854 
    oprot.writeStructEnd()
9855 
 
3431 rajveer 9856 
  def validate(self):
9857 
    return
9858 
 
9859 
 
304 ashish 9860 
  def __repr__(self):
9861 
    L = ['%s=%r' % (key, value)
9862 
      for key, value in self.__dict__.iteritems()]
9863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9864 
 
9865 
  def __eq__(self, other):
9866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9867 
 
9868 
  def __ne__(self, other):
9869 
    return not (self == other)
9870 
 
3064 chandransh 9871 
class markOrdersAsPickedUp_result:
304 ashish 9872 
  """
9873 
  Attributes:
9874 
   - success
3064 chandransh 9875 
   - ex
304 ashish 9876 
  """
9877 
 
9878 
  thrift_spec = (
3064 chandransh 9879 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9880 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9881 
  )
9882 
 
3064 chandransh 9883 
  def __init__(self, success=None, ex=None,):
304 ashish 9884 
    self.success = success
3064 chandransh 9885 
    self.ex = ex
304 ashish 9886 
 
9887 
  def read(self, iprot):
9888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9890 
      return
9891 
    iprot.readStructBegin()
9892 
    while True:
9893 
      (fname, ftype, fid) = iprot.readFieldBegin()
9894 
      if ftype == TType.STOP:
9895 
        break
9896 
      if fid == 0:
9897 
        if ftype == TType.LIST:
9898 
          self.success = []
4133 chandransh 9899 
          (_etype152, _size149) = iprot.readListBegin()
9900 
          for _i153 in xrange(_size149):
9901 
            _elem154 = Order()
9902 
            _elem154.read(iprot)
9903 
            self.success.append(_elem154)
304 ashish 9904 
          iprot.readListEnd()
9905 
        else:
9906 
          iprot.skip(ftype)
3064 chandransh 9907 
      elif fid == 1:
9908 
        if ftype == TType.STRUCT:
9909 
          self.ex = TransactionServiceException()
9910 
          self.ex.read(iprot)
9911 
        else:
9912 
          iprot.skip(ftype)
304 ashish 9913 
      else:
9914 
        iprot.skip(ftype)
9915 
      iprot.readFieldEnd()
9916 
    iprot.readStructEnd()
9917 
 
9918 
  def write(self, oprot):
9919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9921 
      return
3064 chandransh 9922 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9923 
    if self.success is not None:
304 ashish 9924 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9925 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9926 
      for iter155 in self.success:
9927 
        iter155.write(oprot)
304 ashish 9928 
      oprot.writeListEnd()
9929 
      oprot.writeFieldEnd()
3431 rajveer 9930 
    if self.ex is not None:
3064 chandransh 9931 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9932 
      self.ex.write(oprot)
9933 
      oprot.writeFieldEnd()
304 ashish 9934 
    oprot.writeFieldStop()
9935 
    oprot.writeStructEnd()
9936 
 
3431 rajveer 9937 
  def validate(self):
9938 
    return
9939 
 
9940 
 
304 ashish 9941 
  def __repr__(self):
9942 
    L = ['%s=%r' % (key, value)
9943 
      for key, value in self.__dict__.iteritems()]
9944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9945 
 
9946 
  def __eq__(self, other):
9947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9948 
 
9949 
  def __ne__(self, other):
9950 
    return not (self == other)
9951 
 
3064 chandransh 9952 
class markOrdersAsDelivered_args:
304 ashish 9953 
  """
9954 
  Attributes:
3064 chandransh 9955 
   - providerId
9956 
   - deliveredOrders
304 ashish 9957 
  """
9958 
 
9959 
  thrift_spec = (
9960 
    None, # 0
3064 chandransh 9961 
    (1, TType.I64, 'providerId', None, None, ), # 1
9962 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9963 
  )
9964 
 
3064 chandransh 9965 
  def __init__(self, providerId=None, deliveredOrders=None,):
9966 
    self.providerId = providerId
9967 
    self.deliveredOrders = deliveredOrders
304 ashish 9968 
 
9969 
  def read(self, iprot):
9970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9972 
      return
9973 
    iprot.readStructBegin()
9974 
    while True:
9975 
      (fname, ftype, fid) = iprot.readFieldBegin()
9976 
      if ftype == TType.STOP:
9977 
        break
9978 
      if fid == 1:
9979 
        if ftype == TType.I64:
3064 chandransh 9980 
          self.providerId = iprot.readI64();
304 ashish 9981 
        else:
9982 
          iprot.skip(ftype)
9983 
      elif fid == 2:
3064 chandransh 9984 
        if ftype == TType.MAP:
9985 
          self.deliveredOrders = {}
4133 chandransh 9986 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9987 
          for _i160 in xrange(_size156):
9988 
            _key161 = iprot.readString();
9989 
            _val162 = iprot.readString();
9990 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9991 
          iprot.readMapEnd()
304 ashish 9992 
        else:
9993 
          iprot.skip(ftype)
9994 
      else:
9995 
        iprot.skip(ftype)
9996 
      iprot.readFieldEnd()
9997 
    iprot.readStructEnd()
9998 
 
9999 
  def write(self, oprot):
10000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10002 
      return
3064 chandransh 10003 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10004 
    if self.providerId is not None:
3064 chandransh 10005 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10006 
      oprot.writeI64(self.providerId)
304 ashish 10007 
      oprot.writeFieldEnd()
3431 rajveer 10008 
    if self.deliveredOrders is not None:
3064 chandransh 10009 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10010 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10011 
      for kiter163,viter164 in self.deliveredOrders.items():
10012 
        oprot.writeString(kiter163)
10013 
        oprot.writeString(viter164)
3064 chandransh 10014 
      oprot.writeMapEnd()
304 ashish 10015 
      oprot.writeFieldEnd()
10016 
    oprot.writeFieldStop()
10017 
    oprot.writeStructEnd()
10018 
 
3431 rajveer 10019 
  def validate(self):
10020 
    return
10021 
 
10022 
 
304 ashish 10023 
  def __repr__(self):
10024 
    L = ['%s=%r' % (key, value)
10025 
      for key, value in self.__dict__.iteritems()]
10026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10027 
 
10028 
  def __eq__(self, other):
10029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10030 
 
10031 
  def __ne__(self, other):
10032 
    return not (self == other)
10033 
 
3064 chandransh 10034 
class markOrdersAsDelivered_result:
10035 
  """
10036 
  Attributes:
10037 
   - ex
10038 
  """
304 ashish 10039 
 
10040 
  thrift_spec = (
3064 chandransh 10041 
    None, # 0
10042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10043 
  )
10044 
 
3064 chandransh 10045 
  def __init__(self, ex=None,):
10046 
    self.ex = ex
304 ashish 10047 
 
1596 ankur.sing 10048 
  def read(self, iprot):
10049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10051 
      return
10052 
    iprot.readStructBegin()
10053 
    while True:
10054 
      (fname, ftype, fid) = iprot.readFieldBegin()
10055 
      if ftype == TType.STOP:
10056 
        break
3064 chandransh 10057 
      if fid == 1:
10058 
        if ftype == TType.STRUCT:
10059 
          self.ex = TransactionServiceException()
10060 
          self.ex.read(iprot)
10061 
        else:
10062 
          iprot.skip(ftype)
1596 ankur.sing 10063 
      else:
10064 
        iprot.skip(ftype)
10065 
      iprot.readFieldEnd()
10066 
    iprot.readStructEnd()
10067 
 
10068 
  def write(self, oprot):
10069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10071 
      return
3064 chandransh 10072 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10073 
    if self.ex is not None:
3064 chandransh 10074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10075 
      self.ex.write(oprot)
10076 
      oprot.writeFieldEnd()
1596 ankur.sing 10077 
    oprot.writeFieldStop()
10078 
    oprot.writeStructEnd()
10079 
 
3431 rajveer 10080 
  def validate(self):
10081 
    return
10082 
 
10083 
 
1596 ankur.sing 10084 
  def __repr__(self):
10085 
    L = ['%s=%r' % (key, value)
10086 
      for key, value in self.__dict__.iteritems()]
10087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10088 
 
10089 
  def __eq__(self, other):
10090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10091 
 
10092 
  def __ne__(self, other):
10093 
    return not (self == other)
10094 
 
3064 chandransh 10095 
class markOrdersAsFailed_args:
1596 ankur.sing 10096 
  """
10097 
  Attributes:
3064 chandransh 10098 
   - providerId
10099 
   - returnedOrders
1596 ankur.sing 10100 
  """
10101 
 
10102 
  thrift_spec = (
3064 chandransh 10103 
    None, # 0
10104 
    (1, TType.I64, 'providerId', None, None, ), # 1
10105 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10106 
  )
10107 
 
3064 chandransh 10108 
  def __init__(self, providerId=None, returnedOrders=None,):
10109 
    self.providerId = providerId
10110 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10111 
 
10112 
  def read(self, iprot):
10113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10115 
      return
10116 
    iprot.readStructBegin()
10117 
    while True:
10118 
      (fname, ftype, fid) = iprot.readFieldBegin()
10119 
      if ftype == TType.STOP:
10120 
        break
3064 chandransh 10121 
      if fid == 1:
1596 ankur.sing 10122 
        if ftype == TType.I64:
3064 chandransh 10123 
          self.providerId = iprot.readI64();
1596 ankur.sing 10124 
        else:
10125 
          iprot.skip(ftype)
3064 chandransh 10126 
      elif fid == 2:
10127 
        if ftype == TType.MAP:
10128 
          self.returnedOrders = {}
4133 chandransh 10129 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10130 
          for _i169 in xrange(_size165):
10131 
            _key170 = iprot.readString();
10132 
            _val171 = iprot.readString();
10133 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10134 
          iprot.readMapEnd()
10135 
        else:
10136 
          iprot.skip(ftype)
1596 ankur.sing 10137 
      else:
10138 
        iprot.skip(ftype)
10139 
      iprot.readFieldEnd()
10140 
    iprot.readStructEnd()
10141 
 
10142 
  def write(self, oprot):
10143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10145 
      return
3064 chandransh 10146 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10147 
    if self.providerId is not None:
3064 chandransh 10148 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10149 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10150 
      oprot.writeFieldEnd()
3431 rajveer 10151 
    if self.returnedOrders is not None:
3064 chandransh 10152 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10153 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10154 
      for kiter172,viter173 in self.returnedOrders.items():
10155 
        oprot.writeString(kiter172)
10156 
        oprot.writeString(viter173)
3064 chandransh 10157 
      oprot.writeMapEnd()
10158 
      oprot.writeFieldEnd()
1596 ankur.sing 10159 
    oprot.writeFieldStop()
10160 
    oprot.writeStructEnd()
10161 
 
3431 rajveer 10162 
  def validate(self):
10163 
    return
10164 
 
10165 
 
1596 ankur.sing 10166 
  def __repr__(self):
10167 
    L = ['%s=%r' % (key, value)
10168 
      for key, value in self.__dict__.iteritems()]
10169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10170 
 
10171 
  def __eq__(self, other):
10172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10173 
 
10174 
  def __ne__(self, other):
10175 
    return not (self == other)
10176 
 
3064 chandransh 10177 
class markOrdersAsFailed_result:
10178 
  """
10179 
  Attributes:
10180 
   - ex
10181 
  """
1596 ankur.sing 10182 
 
1627 ankur.sing 10183 
  thrift_spec = (
3064 chandransh 10184 
    None, # 0
10185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10186 
  )
10187 
 
3064 chandransh 10188 
  def __init__(self, ex=None,):
10189 
    self.ex = ex
10190 
 
1627 ankur.sing 10191 
  def read(self, iprot):
10192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10194 
      return
10195 
    iprot.readStructBegin()
10196 
    while True:
10197 
      (fname, ftype, fid) = iprot.readFieldBegin()
10198 
      if ftype == TType.STOP:
10199 
        break
3064 chandransh 10200 
      if fid == 1:
10201 
        if ftype == TType.STRUCT:
10202 
          self.ex = TransactionServiceException()
10203 
          self.ex.read(iprot)
10204 
        else:
10205 
          iprot.skip(ftype)
1627 ankur.sing 10206 
      else:
10207 
        iprot.skip(ftype)
10208 
      iprot.readFieldEnd()
10209 
    iprot.readStructEnd()
10210 
 
10211 
  def write(self, oprot):
10212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10214 
      return
3064 chandransh 10215 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10216 
    if self.ex is not None:
3064 chandransh 10217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10218 
      self.ex.write(oprot)
10219 
      oprot.writeFieldEnd()
1627 ankur.sing 10220 
    oprot.writeFieldStop()
10221 
    oprot.writeStructEnd()
10222 
 
3431 rajveer 10223 
  def validate(self):
10224 
    return
10225 
 
10226 
 
1627 ankur.sing 10227 
  def __repr__(self):
10228 
    L = ['%s=%r' % (key, value)
10229 
      for key, value in self.__dict__.iteritems()]
10230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10231 
 
10232 
  def __eq__(self, other):
10233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10234 
 
10235 
  def __ne__(self, other):
10236 
    return not (self == other)
10237 
 
3064 chandransh 10238 
class updateNonDeliveryReason_args:
1627 ankur.sing 10239 
  """
10240 
  Attributes:
3064 chandransh 10241 
   - providerId
10242 
   - undeliveredOrders
1627 ankur.sing 10243 
  """
10244 
 
10245 
  thrift_spec = (
3064 chandransh 10246 
    None, # 0
10247 
    (1, TType.I64, 'providerId', None, None, ), # 1
10248 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10249 
  )
10250 
 
3064 chandransh 10251 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10252 
    self.providerId = providerId
10253 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10254 
 
10255 
  def read(self, iprot):
10256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10258 
      return
10259 
    iprot.readStructBegin()
10260 
    while True:
10261 
      (fname, ftype, fid) = iprot.readFieldBegin()
10262 
      if ftype == TType.STOP:
10263 
        break
3064 chandransh 10264 
      if fid == 1:
1627 ankur.sing 10265 
        if ftype == TType.I64:
3064 chandransh 10266 
          self.providerId = iprot.readI64();
1627 ankur.sing 10267 
        else:
10268 
          iprot.skip(ftype)
3064 chandransh 10269 
      elif fid == 2:
10270 
        if ftype == TType.MAP:
10271 
          self.undeliveredOrders = {}
4133 chandransh 10272 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10273 
          for _i178 in xrange(_size174):
10274 
            _key179 = iprot.readString();
10275 
            _val180 = iprot.readString();
10276 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10277 
          iprot.readMapEnd()
10278 
        else:
10279 
          iprot.skip(ftype)
1627 ankur.sing 10280 
      else:
10281 
        iprot.skip(ftype)
10282 
      iprot.readFieldEnd()
10283 
    iprot.readStructEnd()
10284 
 
10285 
  def write(self, oprot):
10286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10288 
      return
3064 chandransh 10289 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10290 
    if self.providerId is not None:
3064 chandransh 10291 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10292 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10293 
      oprot.writeFieldEnd()
3431 rajveer 10294 
    if self.undeliveredOrders is not None:
3064 chandransh 10295 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10296 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10297 
      for kiter181,viter182 in self.undeliveredOrders.items():
10298 
        oprot.writeString(kiter181)
10299 
        oprot.writeString(viter182)
3064 chandransh 10300 
      oprot.writeMapEnd()
10301 
      oprot.writeFieldEnd()
1627 ankur.sing 10302 
    oprot.writeFieldStop()
10303 
    oprot.writeStructEnd()
10304 
 
3431 rajveer 10305 
  def validate(self):
10306 
    return
10307 
 
10308 
 
1627 ankur.sing 10309 
  def __repr__(self):
10310 
    L = ['%s=%r' % (key, value)
10311 
      for key, value in self.__dict__.iteritems()]
10312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10313 
 
10314 
  def __eq__(self, other):
10315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10316 
 
10317 
  def __ne__(self, other):
10318 
    return not (self == other)
10319 
 
3064 chandransh 10320 
class updateNonDeliveryReason_result:
1627 ankur.sing 10321 
  """
10322 
  Attributes:
3064 chandransh 10323 
   - ex
1627 ankur.sing 10324 
  """
10325 
 
10326 
  thrift_spec = (
3064 chandransh 10327 
    None, # 0
10328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10329 
  )
10330 
 
3064 chandransh 10331 
  def __init__(self, ex=None,):
10332 
    self.ex = ex
1627 ankur.sing 10333 
 
10334 
  def read(self, iprot):
10335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10337 
      return
10338 
    iprot.readStructBegin()
10339 
    while True:
10340 
      (fname, ftype, fid) = iprot.readFieldBegin()
10341 
      if ftype == TType.STOP:
10342 
        break
3064 chandransh 10343 
      if fid == 1:
10344 
        if ftype == TType.STRUCT:
10345 
          self.ex = TransactionServiceException()
10346 
          self.ex.read(iprot)
1627 ankur.sing 10347 
        else:
10348 
          iprot.skip(ftype)
10349 
      else:
10350 
        iprot.skip(ftype)
10351 
      iprot.readFieldEnd()
10352 
    iprot.readStructEnd()
10353 
 
10354 
  def write(self, oprot):
10355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10357 
      return
3064 chandransh 10358 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10359 
    if self.ex is not None:
3064 chandransh 10360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10361 
      self.ex.write(oprot)
1627 ankur.sing 10362 
      oprot.writeFieldEnd()
10363 
    oprot.writeFieldStop()
10364 
    oprot.writeStructEnd()
10365 
 
3431 rajveer 10366 
  def validate(self):
10367 
    return
10368 
 
10369 
 
1627 ankur.sing 10370 
  def __repr__(self):
10371 
    L = ['%s=%r' % (key, value)
10372 
      for key, value in self.__dict__.iteritems()]
10373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10374 
 
10375 
  def __eq__(self, other):
10376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10377 
 
10378 
  def __ne__(self, other):
10379 
    return not (self == other)
10380 
 
3064 chandransh 10381 
class getUndeliveredOrders_args:
1886 ankur.sing 10382 
  """
10383 
  Attributes:
3064 chandransh 10384 
   - providerId
10385 
   - warehouseId
1886 ankur.sing 10386 
  """
1627 ankur.sing 10387 
 
1886 ankur.sing 10388 
  thrift_spec = (
10389 
    None, # 0
3064 chandransh 10390 
    (1, TType.I64, 'providerId', None, None, ), # 1
10391 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10392 
  )
10393 
 
3064 chandransh 10394 
  def __init__(self, providerId=None, warehouseId=None,):
10395 
    self.providerId = providerId
10396 
    self.warehouseId = warehouseId
1886 ankur.sing 10397 
 
10398 
  def read(self, iprot):
10399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10401 
      return
10402 
    iprot.readStructBegin()
10403 
    while True:
10404 
      (fname, ftype, fid) = iprot.readFieldBegin()
10405 
      if ftype == TType.STOP:
10406 
        break
10407 
      if fid == 1:
10408 
        if ftype == TType.I64:
3064 chandransh 10409 
          self.providerId = iprot.readI64();
1886 ankur.sing 10410 
        else:
10411 
          iprot.skip(ftype)
3064 chandransh 10412 
      elif fid == 2:
10413 
        if ftype == TType.I64:
10414 
          self.warehouseId = iprot.readI64();
10415 
        else:
10416 
          iprot.skip(ftype)
1886 ankur.sing 10417 
      else:
10418 
        iprot.skip(ftype)
10419 
      iprot.readFieldEnd()
10420 
    iprot.readStructEnd()
10421 
 
10422 
  def write(self, oprot):
10423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10425 
      return
3064 chandransh 10426 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10427 
    if self.providerId is not None:
3064 chandransh 10428 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10429 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10430 
      oprot.writeFieldEnd()
3431 rajveer 10431 
    if self.warehouseId is not None:
3064 chandransh 10432 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10433 
      oprot.writeI64(self.warehouseId)
10434 
      oprot.writeFieldEnd()
1886 ankur.sing 10435 
    oprot.writeFieldStop()
10436 
    oprot.writeStructEnd()
10437 
 
3431 rajveer 10438 
  def validate(self):
10439 
    return
10440 
 
10441 
 
1886 ankur.sing 10442 
  def __repr__(self):
10443 
    L = ['%s=%r' % (key, value)
10444 
      for key, value in self.__dict__.iteritems()]
10445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10446 
 
10447 
  def __eq__(self, other):
10448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10449 
 
10450 
  def __ne__(self, other):
10451 
    return not (self == other)
10452 
 
3064 chandransh 10453 
class getUndeliveredOrders_result:
1886 ankur.sing 10454 
  """
10455 
  Attributes:
10456 
   - success
10457 
  """
10458 
 
10459 
  thrift_spec = (
10460 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10461 
  )
10462 
 
10463 
  def __init__(self, success=None,):
10464 
    self.success = success
10465 
 
10466 
  def read(self, iprot):
10467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10469 
      return
10470 
    iprot.readStructBegin()
10471 
    while True:
10472 
      (fname, ftype, fid) = iprot.readFieldBegin()
10473 
      if ftype == TType.STOP:
10474 
        break
10475 
      if fid == 0:
10476 
        if ftype == TType.LIST:
10477 
          self.success = []
4133 chandransh 10478 
          (_etype186, _size183) = iprot.readListBegin()
10479 
          for _i187 in xrange(_size183):
10480 
            _elem188 = Order()
10481 
            _elem188.read(iprot)
10482 
            self.success.append(_elem188)
1886 ankur.sing 10483 
          iprot.readListEnd()
10484 
        else:
10485 
          iprot.skip(ftype)
10486 
      else:
10487 
        iprot.skip(ftype)
10488 
      iprot.readFieldEnd()
10489 
    iprot.readStructEnd()
10490 
 
10491 
  def write(self, oprot):
10492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10494 
      return
3064 chandransh 10495 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10496 
    if self.success is not None:
1886 ankur.sing 10497 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10498 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10499 
      for iter189 in self.success:
10500 
        iter189.write(oprot)
1886 ankur.sing 10501 
      oprot.writeListEnd()
10502 
      oprot.writeFieldEnd()
10503 
    oprot.writeFieldStop()
10504 
    oprot.writeStructEnd()
10505 
 
3431 rajveer 10506 
  def validate(self):
10507 
    return
10508 
 
10509 
 
1886 ankur.sing 10510 
  def __repr__(self):
10511 
    L = ['%s=%r' % (key, value)
10512 
      for key, value in self.__dict__.iteritems()]
10513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10514 
 
10515 
  def __eq__(self, other):
10516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10517 
 
10518 
  def __ne__(self, other):
10519 
    return not (self == other)
10520 
 
2536 chandransh 10521 
class toggleDOAFlag_args:
10522 
  """
10523 
  Attributes:
10524 
   - orderId
10525 
  """
1886 ankur.sing 10526 
 
2536 chandransh 10527 
  thrift_spec = (
10528 
    None, # 0
10529 
    (1, TType.I64, 'orderId', None, None, ), # 1
10530 
  )
10531 
 
10532 
  def __init__(self, orderId=None,):
10533 
    self.orderId = orderId
10534 
 
10535 
  def read(self, iprot):
10536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10538 
      return
10539 
    iprot.readStructBegin()
10540 
    while True:
10541 
      (fname, ftype, fid) = iprot.readFieldBegin()
10542 
      if ftype == TType.STOP:
10543 
        break
10544 
      if fid == 1:
10545 
        if ftype == TType.I64:
10546 
          self.orderId = iprot.readI64();
10547 
        else:
10548 
          iprot.skip(ftype)
10549 
      else:
10550 
        iprot.skip(ftype)
10551 
      iprot.readFieldEnd()
10552 
    iprot.readStructEnd()
10553 
 
10554 
  def write(self, oprot):
10555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10557 
      return
10558 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10559 
    if self.orderId is not None:
2536 chandransh 10560 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10561 
      oprot.writeI64(self.orderId)
10562 
      oprot.writeFieldEnd()
10563 
    oprot.writeFieldStop()
10564 
    oprot.writeStructEnd()
10565 
 
3431 rajveer 10566 
  def validate(self):
10567 
    return
10568 
 
10569 
 
2536 chandransh 10570 
  def __repr__(self):
10571 
    L = ['%s=%r' % (key, value)
10572 
      for key, value in self.__dict__.iteritems()]
10573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10574 
 
10575 
  def __eq__(self, other):
10576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10577 
 
10578 
  def __ne__(self, other):
10579 
    return not (self == other)
10580 
 
10581 
class toggleDOAFlag_result:
10582 
  """
10583 
  Attributes:
10584 
   - success
10585 
   - ex
10586 
  """
10587 
 
10588 
  thrift_spec = (
10589 
    (0, TType.BOOL, 'success', None, None, ), # 0
10590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10591 
  )
10592 
 
10593 
  def __init__(self, success=None, ex=None,):
10594 
    self.success = success
10595 
    self.ex = ex
10596 
 
10597 
  def read(self, iprot):
10598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10600 
      return
10601 
    iprot.readStructBegin()
10602 
    while True:
10603 
      (fname, ftype, fid) = iprot.readFieldBegin()
10604 
      if ftype == TType.STOP:
10605 
        break
10606 
      if fid == 0:
10607 
        if ftype == TType.BOOL:
10608 
          self.success = iprot.readBool();
10609 
        else:
10610 
          iprot.skip(ftype)
10611 
      elif fid == 1:
10612 
        if ftype == TType.STRUCT:
10613 
          self.ex = TransactionServiceException()
10614 
          self.ex.read(iprot)
10615 
        else:
10616 
          iprot.skip(ftype)
10617 
      else:
10618 
        iprot.skip(ftype)
10619 
      iprot.readFieldEnd()
10620 
    iprot.readStructEnd()
10621 
 
10622 
  def write(self, oprot):
10623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10625 
      return
10626 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10627 
    if self.success is not None:
2536 chandransh 10628 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10629 
      oprot.writeBool(self.success)
10630 
      oprot.writeFieldEnd()
3431 rajveer 10631 
    if self.ex is not None:
2536 chandransh 10632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10633 
      self.ex.write(oprot)
10634 
      oprot.writeFieldEnd()
10635 
    oprot.writeFieldStop()
10636 
    oprot.writeStructEnd()
10637 
 
3431 rajveer 10638 
  def validate(self):
10639 
    return
10640 
 
10641 
 
2536 chandransh 10642 
  def __repr__(self):
10643 
    L = ['%s=%r' % (key, value)
10644 
      for key, value in self.__dict__.iteritems()]
10645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10646 
 
10647 
  def __eq__(self, other):
10648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10649 
 
10650 
  def __ne__(self, other):
10651 
    return not (self == other)
10652 
 
4454 rajveer 10653 
class markOrderDoaRequestReceived_args:
10654 
  """
10655 
  Attributes:
10656 
   - orderId
10657 
  """
10658 
 
10659 
  thrift_spec = (
10660 
    None, # 0
10661 
    (1, TType.I64, 'orderId', None, None, ), # 1
10662 
  )
10663 
 
10664 
  def __init__(self, orderId=None,):
10665 
    self.orderId = orderId
10666 
 
10667 
  def read(self, iprot):
10668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10670 
      return
10671 
    iprot.readStructBegin()
10672 
    while True:
10673 
      (fname, ftype, fid) = iprot.readFieldBegin()
10674 
      if ftype == TType.STOP:
10675 
        break
10676 
      if fid == 1:
10677 
        if ftype == TType.I64:
10678 
          self.orderId = iprot.readI64();
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      else:
10682 
        iprot.skip(ftype)
10683 
      iprot.readFieldEnd()
10684 
    iprot.readStructEnd()
10685 
 
10686 
  def write(self, oprot):
10687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10689 
      return
10690 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
10691 
    if self.orderId is not None:
10692 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10693 
      oprot.writeI64(self.orderId)
10694 
      oprot.writeFieldEnd()
10695 
    oprot.writeFieldStop()
10696 
    oprot.writeStructEnd()
10697 
 
10698 
  def validate(self):
10699 
    return
10700 
 
10701 
 
10702 
  def __repr__(self):
10703 
    L = ['%s=%r' % (key, value)
10704 
      for key, value in self.__dict__.iteritems()]
10705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10706 
 
10707 
  def __eq__(self, other):
10708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10709 
 
10710 
  def __ne__(self, other):
10711 
    return not (self == other)
10712 
 
10713 
class markOrderDoaRequestReceived_result:
10714 
  """
10715 
  Attributes:
10716 
   - success
10717 
   - ex
10718 
  """
10719 
 
10720 
  thrift_spec = (
10721 
    (0, TType.BOOL, 'success', None, None, ), # 0
10722 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10723 
  )
10724 
 
10725 
  def __init__(self, success=None, ex=None,):
10726 
    self.success = success
10727 
    self.ex = ex
10728 
 
10729 
  def read(self, iprot):
10730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10732 
      return
10733 
    iprot.readStructBegin()
10734 
    while True:
10735 
      (fname, ftype, fid) = iprot.readFieldBegin()
10736 
      if ftype == TType.STOP:
10737 
        break
10738 
      if fid == 0:
10739 
        if ftype == TType.BOOL:
10740 
          self.success = iprot.readBool();
10741 
        else:
10742 
          iprot.skip(ftype)
10743 
      elif fid == 1:
10744 
        if ftype == TType.STRUCT:
10745 
          self.ex = TransactionServiceException()
10746 
          self.ex.read(iprot)
10747 
        else:
10748 
          iprot.skip(ftype)
10749 
      else:
10750 
        iprot.skip(ftype)
10751 
      iprot.readFieldEnd()
10752 
    iprot.readStructEnd()
10753 
 
10754 
  def write(self, oprot):
10755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10757 
      return
10758 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
10759 
    if self.success is not None:
10760 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10761 
      oprot.writeBool(self.success)
10762 
      oprot.writeFieldEnd()
10763 
    if self.ex is not None:
10764 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10765 
      self.ex.write(oprot)
10766 
      oprot.writeFieldEnd()
10767 
    oprot.writeFieldStop()
10768 
    oprot.writeStructEnd()
10769 
 
10770 
  def validate(self):
10771 
    return
10772 
 
10773 
 
10774 
  def __repr__(self):
10775 
    L = ['%s=%r' % (key, value)
10776 
      for key, value in self.__dict__.iteritems()]
10777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10778 
 
10779 
  def __eq__(self, other):
10780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10781 
 
10782 
  def __ne__(self, other):
10783 
    return not (self == other)
10784 
 
10785 
class markOrderDoaRequestAuthorized_args:
10786 
  """
10787 
  Attributes:
10788 
   - orderId
10789 
   - isAuthorized
10790 
  """
10791 
 
10792 
  thrift_spec = (
10793 
    None, # 0
10794 
    (1, TType.I64, 'orderId', None, None, ), # 1
10795 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
10796 
  )
10797 
 
10798 
  def __init__(self, orderId=None, isAuthorized=None,):
10799 
    self.orderId = orderId
10800 
    self.isAuthorized = isAuthorized
10801 
 
10802 
  def read(self, iprot):
10803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10805 
      return
10806 
    iprot.readStructBegin()
10807 
    while True:
10808 
      (fname, ftype, fid) = iprot.readFieldBegin()
10809 
      if ftype == TType.STOP:
10810 
        break
10811 
      if fid == 1:
10812 
        if ftype == TType.I64:
10813 
          self.orderId = iprot.readI64();
10814 
        else:
10815 
          iprot.skip(ftype)
10816 
      elif fid == 2:
10817 
        if ftype == TType.BOOL:
10818 
          self.isAuthorized = iprot.readBool();
10819 
        else:
10820 
          iprot.skip(ftype)
10821 
      else:
10822 
        iprot.skip(ftype)
10823 
      iprot.readFieldEnd()
10824 
    iprot.readStructEnd()
10825 
 
10826 
  def write(self, oprot):
10827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10829 
      return
10830 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
10831 
    if self.orderId is not None:
10832 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10833 
      oprot.writeI64(self.orderId)
10834 
      oprot.writeFieldEnd()
10835 
    if self.isAuthorized is not None:
10836 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
10837 
      oprot.writeBool(self.isAuthorized)
10838 
      oprot.writeFieldEnd()
10839 
    oprot.writeFieldStop()
10840 
    oprot.writeStructEnd()
10841 
 
10842 
  def validate(self):
10843 
    return
10844 
 
10845 
 
10846 
  def __repr__(self):
10847 
    L = ['%s=%r' % (key, value)
10848 
      for key, value in self.__dict__.iteritems()]
10849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10850 
 
10851 
  def __eq__(self, other):
10852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10853 
 
10854 
  def __ne__(self, other):
10855 
    return not (self == other)
10856 
 
10857 
class markOrderDoaRequestAuthorized_result:
10858 
  """
10859 
  Attributes:
10860 
   - success
10861 
   - ex
10862 
  """
10863 
 
10864 
  thrift_spec = (
10865 
    (0, TType.BOOL, 'success', None, None, ), # 0
10866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10867 
  )
10868 
 
10869 
  def __init__(self, success=None, ex=None,):
10870 
    self.success = success
10871 
    self.ex = ex
10872 
 
10873 
  def read(self, iprot):
10874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10876 
      return
10877 
    iprot.readStructBegin()
10878 
    while True:
10879 
      (fname, ftype, fid) = iprot.readFieldBegin()
10880 
      if ftype == TType.STOP:
10881 
        break
10882 
      if fid == 0:
10883 
        if ftype == TType.BOOL:
10884 
          self.success = iprot.readBool();
10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      elif fid == 1:
10888 
        if ftype == TType.STRUCT:
10889 
          self.ex = TransactionServiceException()
10890 
          self.ex.read(iprot)
10891 
        else:
10892 
          iprot.skip(ftype)
10893 
      else:
10894 
        iprot.skip(ftype)
10895 
      iprot.readFieldEnd()
10896 
    iprot.readStructEnd()
10897 
 
10898 
  def write(self, oprot):
10899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10901 
      return
10902 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
10903 
    if self.success is not None:
10904 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10905 
      oprot.writeBool(self.success)
10906 
      oprot.writeFieldEnd()
10907 
    if self.ex is not None:
10908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10909 
      self.ex.write(oprot)
10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
10914 
  def validate(self):
10915 
    return
10916 
 
10917 
 
10918 
  def __repr__(self):
10919 
    L = ['%s=%r' % (key, value)
10920 
      for key, value in self.__dict__.iteritems()]
10921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10922 
 
10923 
  def __eq__(self, other):
10924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10925 
 
10926 
  def __ne__(self, other):
10927 
    return not (self == other)
10928 
 
2536 chandransh 10929 
class requestPickupNumber_args:
10930 
  """
10931 
  Attributes:
10932 
   - orderId
10933 
  """
10934 
 
10935 
  thrift_spec = (
10936 
    None, # 0
10937 
    (1, TType.I64, 'orderId', None, None, ), # 1
10938 
  )
10939 
 
10940 
  def __init__(self, orderId=None,):
10941 
    self.orderId = orderId
10942 
 
10943 
  def read(self, iprot):
10944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10946 
      return
10947 
    iprot.readStructBegin()
10948 
    while True:
10949 
      (fname, ftype, fid) = iprot.readFieldBegin()
10950 
      if ftype == TType.STOP:
10951 
        break
10952 
      if fid == 1:
10953 
        if ftype == TType.I64:
10954 
          self.orderId = iprot.readI64();
10955 
        else:
10956 
          iprot.skip(ftype)
10957 
      else:
10958 
        iprot.skip(ftype)
10959 
      iprot.readFieldEnd()
10960 
    iprot.readStructEnd()
10961 
 
10962 
  def write(self, oprot):
10963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10965 
      return
10966 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10967 
    if self.orderId is not None:
2536 chandransh 10968 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10969 
      oprot.writeI64(self.orderId)
10970 
      oprot.writeFieldEnd()
10971 
    oprot.writeFieldStop()
10972 
    oprot.writeStructEnd()
10973 
 
3431 rajveer 10974 
  def validate(self):
10975 
    return
10976 
 
10977 
 
2536 chandransh 10978 
  def __repr__(self):
10979 
    L = ['%s=%r' % (key, value)
10980 
      for key, value in self.__dict__.iteritems()]
10981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10982 
 
10983 
  def __eq__(self, other):
10984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10985 
 
10986 
  def __ne__(self, other):
10987 
    return not (self == other)
10988 
 
10989 
class requestPickupNumber_result:
10990 
  """
10991 
  Attributes:
10992 
   - success
10993 
   - ex
10994 
  """
10995 
 
10996 
  thrift_spec = (
10997 
    (0, TType.BOOL, 'success', None, None, ), # 0
10998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10999 
  )
11000 
 
11001 
  def __init__(self, success=None, ex=None,):
11002 
    self.success = success
11003 
    self.ex = ex
11004 
 
11005 
  def read(self, iprot):
11006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11008 
      return
11009 
    iprot.readStructBegin()
11010 
    while True:
11011 
      (fname, ftype, fid) = iprot.readFieldBegin()
11012 
      if ftype == TType.STOP:
11013 
        break
11014 
      if fid == 0:
11015 
        if ftype == TType.BOOL:
11016 
          self.success = iprot.readBool();
11017 
        else:
11018 
          iprot.skip(ftype)
11019 
      elif fid == 1:
11020 
        if ftype == TType.STRUCT:
11021 
          self.ex = TransactionServiceException()
11022 
          self.ex.read(iprot)
11023 
        else:
11024 
          iprot.skip(ftype)
11025 
      else:
11026 
        iprot.skip(ftype)
11027 
      iprot.readFieldEnd()
11028 
    iprot.readStructEnd()
11029 
 
11030 
  def write(self, oprot):
11031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11033 
      return
11034 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11035 
    if self.success is not None:
2536 chandransh 11036 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11037 
      oprot.writeBool(self.success)
11038 
      oprot.writeFieldEnd()
3431 rajveer 11039 
    if self.ex is not None:
2536 chandransh 11040 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11041 
      self.ex.write(oprot)
11042 
      oprot.writeFieldEnd()
11043 
    oprot.writeFieldStop()
11044 
    oprot.writeStructEnd()
11045 
 
3431 rajveer 11046 
  def validate(self):
11047 
    return
11048 
 
11049 
 
2536 chandransh 11050 
  def __repr__(self):
11051 
    L = ['%s=%r' % (key, value)
11052 
      for key, value in self.__dict__.iteritems()]
11053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11054 
 
11055 
  def __eq__(self, other):
11056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11057 
 
11058 
  def __ne__(self, other):
11059 
    return not (self == other)
11060 
 
11061 
class authorizePickup_args:
11062 
  """
11063 
  Attributes:
11064 
   - orderId
11065 
   - pickupNumber
11066 
  """
11067 
 
11068 
  thrift_spec = (
11069 
    None, # 0
11070 
    (1, TType.I64, 'orderId', None, None, ), # 1
11071 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11072 
  )
11073 
 
11074 
  def __init__(self, orderId=None, pickupNumber=None,):
11075 
    self.orderId = orderId
11076 
    self.pickupNumber = pickupNumber
11077 
 
11078 
  def read(self, iprot):
11079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11081 
      return
11082 
    iprot.readStructBegin()
11083 
    while True:
11084 
      (fname, ftype, fid) = iprot.readFieldBegin()
11085 
      if ftype == TType.STOP:
11086 
        break
11087 
      if fid == 1:
11088 
        if ftype == TType.I64:
11089 
          self.orderId = iprot.readI64();
11090 
        else:
11091 
          iprot.skip(ftype)
11092 
      elif fid == 2:
11093 
        if ftype == TType.STRING:
11094 
          self.pickupNumber = iprot.readString();
11095 
        else:
11096 
          iprot.skip(ftype)
11097 
      else:
11098 
        iprot.skip(ftype)
11099 
      iprot.readFieldEnd()
11100 
    iprot.readStructEnd()
11101 
 
11102 
  def write(self, oprot):
11103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11105 
      return
11106 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11107 
    if self.orderId is not None:
2536 chandransh 11108 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11109 
      oprot.writeI64(self.orderId)
11110 
      oprot.writeFieldEnd()
3431 rajveer 11111 
    if self.pickupNumber is not None:
2536 chandransh 11112 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11113 
      oprot.writeString(self.pickupNumber)
11114 
      oprot.writeFieldEnd()
11115 
    oprot.writeFieldStop()
11116 
    oprot.writeStructEnd()
11117 
 
3431 rajveer 11118 
  def validate(self):
11119 
    return
11120 
 
11121 
 
2536 chandransh 11122 
  def __repr__(self):
11123 
    L = ['%s=%r' % (key, value)
11124 
      for key, value in self.__dict__.iteritems()]
11125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11126 
 
11127 
  def __eq__(self, other):
11128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11129 
 
11130 
  def __ne__(self, other):
11131 
    return not (self == other)
11132 
 
11133 
class authorizePickup_result:
11134 
  """
11135 
  Attributes:
11136 
   - success
11137 
   - ex
11138 
  """
11139 
 
11140 
  thrift_spec = (
11141 
    (0, TType.BOOL, 'success', None, None, ), # 0
11142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11143 
  )
11144 
 
11145 
  def __init__(self, success=None, ex=None,):
11146 
    self.success = success
11147 
    self.ex = ex
11148 
 
11149 
  def read(self, iprot):
11150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11152 
      return
11153 
    iprot.readStructBegin()
11154 
    while True:
11155 
      (fname, ftype, fid) = iprot.readFieldBegin()
11156 
      if ftype == TType.STOP:
11157 
        break
11158 
      if fid == 0:
11159 
        if ftype == TType.BOOL:
11160 
          self.success = iprot.readBool();
11161 
        else:
11162 
          iprot.skip(ftype)
11163 
      elif fid == 1:
11164 
        if ftype == TType.STRUCT:
11165 
          self.ex = TransactionServiceException()
11166 
          self.ex.read(iprot)
11167 
        else:
11168 
          iprot.skip(ftype)
11169 
      else:
11170 
        iprot.skip(ftype)
11171 
      iprot.readFieldEnd()
11172 
    iprot.readStructEnd()
11173 
 
11174 
  def write(self, oprot):
11175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11177 
      return
11178 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11179 
    if self.success is not None:
2536 chandransh 11180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11181 
      oprot.writeBool(self.success)
11182 
      oprot.writeFieldEnd()
3431 rajveer 11183 
    if self.ex is not None:
2536 chandransh 11184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11185 
      self.ex.write(oprot)
11186 
      oprot.writeFieldEnd()
11187 
    oprot.writeFieldStop()
11188 
    oprot.writeStructEnd()
11189 
 
3431 rajveer 11190 
  def validate(self):
11191 
    return
11192 
 
11193 
 
2536 chandransh 11194 
  def __repr__(self):
11195 
    L = ['%s=%r' % (key, value)
11196 
      for key, value in self.__dict__.iteritems()]
11197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11198 
 
11199 
  def __eq__(self, other):
11200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11201 
 
11202 
  def __ne__(self, other):
11203 
    return not (self == other)
11204 
 
2764 chandransh 11205 
class markDoasAsPickedUp_args:
11206 
  """
11207 
  Attributes:
11208 
   - providerId
11209 
   - pickupDetails
11210 
  """
11211 
 
11212 
  thrift_spec = (
11213 
    None, # 0
11214 
    (1, TType.I64, 'providerId', None, None, ), # 1
11215 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11216 
  )
11217 
 
11218 
  def __init__(self, providerId=None, pickupDetails=None,):
11219 
    self.providerId = providerId
11220 
    self.pickupDetails = pickupDetails
11221 
 
11222 
  def read(self, iprot):
11223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11225 
      return
11226 
    iprot.readStructBegin()
11227 
    while True:
11228 
      (fname, ftype, fid) = iprot.readFieldBegin()
11229 
      if ftype == TType.STOP:
11230 
        break
11231 
      if fid == 1:
11232 
        if ftype == TType.I64:
11233 
          self.providerId = iprot.readI64();
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      elif fid == 2:
11237 
        if ftype == TType.MAP:
11238 
          self.pickupDetails = {}
4133 chandransh 11239 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
11240 
          for _i194 in xrange(_size190):
11241 
            _key195 = iprot.readString();
11242 
            _val196 = iprot.readString();
11243 
            self.pickupDetails[_key195] = _val196
2764 chandransh 11244 
          iprot.readMapEnd()
11245 
        else:
11246 
          iprot.skip(ftype)
11247 
      else:
11248 
        iprot.skip(ftype)
11249 
      iprot.readFieldEnd()
11250 
    iprot.readStructEnd()
11251 
 
11252 
  def write(self, oprot):
11253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11255 
      return
11256 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 11257 
    if self.providerId is not None:
2764 chandransh 11258 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11259 
      oprot.writeI64(self.providerId)
11260 
      oprot.writeFieldEnd()
3431 rajveer 11261 
    if self.pickupDetails is not None:
2764 chandransh 11262 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11263 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11264 
      for kiter197,viter198 in self.pickupDetails.items():
11265 
        oprot.writeString(kiter197)
11266 
        oprot.writeString(viter198)
2764 chandransh 11267 
      oprot.writeMapEnd()
11268 
      oprot.writeFieldEnd()
11269 
    oprot.writeFieldStop()
11270 
    oprot.writeStructEnd()
11271 
 
3431 rajveer 11272 
  def validate(self):
11273 
    return
11274 
 
11275 
 
2764 chandransh 11276 
  def __repr__(self):
11277 
    L = ['%s=%r' % (key, value)
11278 
      for key, value in self.__dict__.iteritems()]
11279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11280 
 
11281 
  def __eq__(self, other):
11282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11283 
 
11284 
  def __ne__(self, other):
11285 
    return not (self == other)
11286 
 
11287 
class markDoasAsPickedUp_result:
11288 
  """
11289 
  Attributes:
11290 
   - success
11291 
  """
11292 
 
11293 
  thrift_spec = (
11294 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11295 
  )
11296 
 
11297 
  def __init__(self, success=None,):
11298 
    self.success = success
11299 
 
11300 
  def read(self, iprot):
11301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11303 
      return
11304 
    iprot.readStructBegin()
11305 
    while True:
11306 
      (fname, ftype, fid) = iprot.readFieldBegin()
11307 
      if ftype == TType.STOP:
11308 
        break
11309 
      if fid == 0:
11310 
        if ftype == TType.LIST:
11311 
          self.success = []
4133 chandransh 11312 
          (_etype202, _size199) = iprot.readListBegin()
11313 
          for _i203 in xrange(_size199):
11314 
            _elem204 = Order()
11315 
            _elem204.read(iprot)
11316 
            self.success.append(_elem204)
2764 chandransh 11317 
          iprot.readListEnd()
11318 
        else:
11319 
          iprot.skip(ftype)
11320 
      else:
11321 
        iprot.skip(ftype)
11322 
      iprot.readFieldEnd()
11323 
    iprot.readStructEnd()
11324 
 
11325 
  def write(self, oprot):
11326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11328 
      return
11329 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 11330 
    if self.success is not None:
2764 chandransh 11331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11332 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11333 
      for iter205 in self.success:
11334 
        iter205.write(oprot)
2764 chandransh 11335 
      oprot.writeListEnd()
11336 
      oprot.writeFieldEnd()
11337 
    oprot.writeFieldStop()
11338 
    oprot.writeStructEnd()
11339 
 
3431 rajveer 11340 
  def validate(self):
11341 
    return
11342 
 
11343 
 
2764 chandransh 11344 
  def __repr__(self):
11345 
    L = ['%s=%r' % (key, value)
11346 
      for key, value in self.__dict__.iteritems()]
11347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11348 
 
11349 
  def __eq__(self, other):
11350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11351 
 
11352 
  def __ne__(self, other):
11353 
    return not (self == other)
11354 
 
2616 chandransh 11355 
class receiveReturn_args:
2591 chandransh 11356 
  """
11357 
  Attributes:
11358 
   - orderId
4479 rajveer 11359 
   - receiveCondition
2591 chandransh 11360 
  """
2536 chandransh 11361 
 
2591 chandransh 11362 
  thrift_spec = (
11363 
    None, # 0
11364 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 11365 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 11366 
  )
11367 
 
4479 rajveer 11368 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 11369 
    self.orderId = orderId
4479 rajveer 11370 
    self.receiveCondition = receiveCondition
2591 chandransh 11371 
 
11372 
  def read(self, iprot):
11373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11375 
      return
11376 
    iprot.readStructBegin()
11377 
    while True:
11378 
      (fname, ftype, fid) = iprot.readFieldBegin()
11379 
      if ftype == TType.STOP:
11380 
        break
11381 
      if fid == 1:
11382 
        if ftype == TType.I64:
11383 
          self.orderId = iprot.readI64();
11384 
        else:
11385 
          iprot.skip(ftype)
4479 rajveer 11386 
      elif fid == 2:
11387 
        if ftype == TType.I64:
11388 
          self.receiveCondition = iprot.readI64();
11389 
        else:
11390 
          iprot.skip(ftype)
2591 chandransh 11391 
      else:
11392 
        iprot.skip(ftype)
11393 
      iprot.readFieldEnd()
11394 
    iprot.readStructEnd()
11395 
 
11396 
  def write(self, oprot):
11397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11399 
      return
2616 chandransh 11400 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 11401 
    if self.orderId is not None:
2591 chandransh 11402 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11403 
      oprot.writeI64(self.orderId)
11404 
      oprot.writeFieldEnd()
4479 rajveer 11405 
    if self.receiveCondition is not None:
11406 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
11407 
      oprot.writeI64(self.receiveCondition)
11408 
      oprot.writeFieldEnd()
2591 chandransh 11409 
    oprot.writeFieldStop()
11410 
    oprot.writeStructEnd()
11411 
 
3431 rajveer 11412 
  def validate(self):
11413 
    return
11414 
 
11415 
 
2591 chandransh 11416 
  def __repr__(self):
11417 
    L = ['%s=%r' % (key, value)
11418 
      for key, value in self.__dict__.iteritems()]
11419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11420 
 
11421 
  def __eq__(self, other):
11422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11423 
 
11424 
  def __ne__(self, other):
11425 
    return not (self == other)
11426 
 
2616 chandransh 11427 
class receiveReturn_result:
2591 chandransh 11428 
  """
11429 
  Attributes:
11430 
   - success
11431 
   - ex
11432 
  """
11433 
 
11434 
  thrift_spec = (
11435 
    (0, TType.BOOL, 'success', None, None, ), # 0
11436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11437 
  )
11438 
 
11439 
  def __init__(self, success=None, ex=None,):
11440 
    self.success = success
11441 
    self.ex = ex
11442 
 
11443 
  def read(self, iprot):
11444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11446 
      return
11447 
    iprot.readStructBegin()
11448 
    while True:
11449 
      (fname, ftype, fid) = iprot.readFieldBegin()
11450 
      if ftype == TType.STOP:
11451 
        break
11452 
      if fid == 0:
11453 
        if ftype == TType.BOOL:
11454 
          self.success = iprot.readBool();
11455 
        else:
11456 
          iprot.skip(ftype)
11457 
      elif fid == 1:
11458 
        if ftype == TType.STRUCT:
11459 
          self.ex = TransactionServiceException()
11460 
          self.ex.read(iprot)
11461 
        else:
11462 
          iprot.skip(ftype)
11463 
      else:
11464 
        iprot.skip(ftype)
11465 
      iprot.readFieldEnd()
11466 
    iprot.readStructEnd()
11467 
 
11468 
  def write(self, oprot):
11469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11471 
      return
2616 chandransh 11472 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 11473 
    if self.success is not None:
2591 chandransh 11474 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11475 
      oprot.writeBool(self.success)
11476 
      oprot.writeFieldEnd()
3431 rajveer 11477 
    if self.ex is not None:
2591 chandransh 11478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11479 
      self.ex.write(oprot)
11480 
      oprot.writeFieldEnd()
11481 
    oprot.writeFieldStop()
11482 
    oprot.writeStructEnd()
11483 
 
3431 rajveer 11484 
  def validate(self):
11485 
    return
11486 
 
11487 
 
2591 chandransh 11488 
  def __repr__(self):
11489 
    L = ['%s=%r' % (key, value)
11490 
      for key, value in self.__dict__.iteritems()]
11491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11492 
 
11493 
  def __eq__(self, other):
11494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11495 
 
11496 
  def __ne__(self, other):
11497 
    return not (self == other)
11498 
 
11499 
class validateDoa_args:
11500 
  """
11501 
  Attributes:
11502 
   - orderId
11503 
   - isValid
11504 
  """
11505 
 
11506 
  thrift_spec = (
11507 
    None, # 0
11508 
    (1, TType.I64, 'orderId', None, None, ), # 1
11509 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
11510 
  )
11511 
 
11512 
  def __init__(self, orderId=None, isValid=None,):
11513 
    self.orderId = orderId
11514 
    self.isValid = isValid
11515 
 
11516 
  def read(self, iprot):
11517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11519 
      return
11520 
    iprot.readStructBegin()
11521 
    while True:
11522 
      (fname, ftype, fid) = iprot.readFieldBegin()
11523 
      if ftype == TType.STOP:
11524 
        break
11525 
      if fid == 1:
11526 
        if ftype == TType.I64:
11527 
          self.orderId = iprot.readI64();
11528 
        else:
11529 
          iprot.skip(ftype)
11530 
      elif fid == 2:
11531 
        if ftype == TType.BOOL:
11532 
          self.isValid = iprot.readBool();
11533 
        else:
11534 
          iprot.skip(ftype)
11535 
      else:
11536 
        iprot.skip(ftype)
11537 
      iprot.readFieldEnd()
11538 
    iprot.readStructEnd()
11539 
 
11540 
  def write(self, oprot):
11541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11543 
      return
11544 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 11545 
    if self.orderId is not None:
2591 chandransh 11546 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11547 
      oprot.writeI64(self.orderId)
11548 
      oprot.writeFieldEnd()
3431 rajveer 11549 
    if self.isValid is not None:
2591 chandransh 11550 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
11551 
      oprot.writeBool(self.isValid)
11552 
      oprot.writeFieldEnd()
11553 
    oprot.writeFieldStop()
11554 
    oprot.writeStructEnd()
11555 
 
3431 rajveer 11556 
  def validate(self):
11557 
    return
11558 
 
11559 
 
2591 chandransh 11560 
  def __repr__(self):
11561 
    L = ['%s=%r' % (key, value)
11562 
      for key, value in self.__dict__.iteritems()]
11563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11564 
 
11565 
  def __eq__(self, other):
11566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11567 
 
11568 
  def __ne__(self, other):
11569 
    return not (self == other)
11570 
 
11571 
class validateDoa_result:
11572 
  """
11573 
  Attributes:
11574 
   - success
11575 
   - ex
11576 
  """
11577 
 
11578 
  thrift_spec = (
11579 
    (0, TType.BOOL, 'success', None, None, ), # 0
11580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11581 
  )
11582 
 
11583 
  def __init__(self, success=None, ex=None,):
11584 
    self.success = success
11585 
    self.ex = ex
11586 
 
11587 
  def read(self, iprot):
11588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11590 
      return
11591 
    iprot.readStructBegin()
11592 
    while True:
11593 
      (fname, ftype, fid) = iprot.readFieldBegin()
11594 
      if ftype == TType.STOP:
11595 
        break
11596 
      if fid == 0:
11597 
        if ftype == TType.BOOL:
11598 
          self.success = iprot.readBool();
11599 
        else:
11600 
          iprot.skip(ftype)
11601 
      elif fid == 1:
11602 
        if ftype == TType.STRUCT:
11603 
          self.ex = TransactionServiceException()
11604 
          self.ex.read(iprot)
11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
11616 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 11617 
    if self.success is not None:
2591 chandransh 11618 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11619 
      oprot.writeBool(self.success)
11620 
      oprot.writeFieldEnd()
3431 rajveer 11621 
    if self.ex is not None:
2591 chandransh 11622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11623 
      self.ex.write(oprot)
11624 
      oprot.writeFieldEnd()
11625 
    oprot.writeFieldStop()
11626 
    oprot.writeStructEnd()
11627 
 
3431 rajveer 11628 
  def validate(self):
11629 
    return
11630 
 
11631 
 
2591 chandransh 11632 
  def __repr__(self):
11633 
    L = ['%s=%r' % (key, value)
11634 
      for key, value in self.__dict__.iteritems()]
11635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11636 
 
11637 
  def __eq__(self, other):
11638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11639 
 
11640 
  def __ne__(self, other):
11641 
    return not (self == other)
11642 
 
2616 chandransh 11643 
class reshipOrder_args:
11644 
  """
11645 
  Attributes:
11646 
   - orderId
11647 
  """
2591 chandransh 11648 
 
2616 chandransh 11649 
  thrift_spec = (
11650 
    None, # 0
11651 
    (1, TType.I64, 'orderId', None, None, ), # 1
11652 
  )
11653 
 
11654 
  def __init__(self, orderId=None,):
11655 
    self.orderId = orderId
11656 
 
11657 
  def read(self, iprot):
11658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11660 
      return
11661 
    iprot.readStructBegin()
11662 
    while True:
11663 
      (fname, ftype, fid) = iprot.readFieldBegin()
11664 
      if ftype == TType.STOP:
11665 
        break
11666 
      if fid == 1:
11667 
        if ftype == TType.I64:
11668 
          self.orderId = iprot.readI64();
11669 
        else:
11670 
          iprot.skip(ftype)
11671 
      else:
11672 
        iprot.skip(ftype)
11673 
      iprot.readFieldEnd()
11674 
    iprot.readStructEnd()
11675 
 
11676 
  def write(self, oprot):
11677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11679 
      return
11680 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 11681 
    if self.orderId is not None:
2616 chandransh 11682 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11683 
      oprot.writeI64(self.orderId)
11684 
      oprot.writeFieldEnd()
11685 
    oprot.writeFieldStop()
11686 
    oprot.writeStructEnd()
11687 
 
3431 rajveer 11688 
  def validate(self):
11689 
    return
11690 
 
11691 
 
2616 chandransh 11692 
  def __repr__(self):
11693 
    L = ['%s=%r' % (key, value)
11694 
      for key, value in self.__dict__.iteritems()]
11695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11696 
 
11697 
  def __eq__(self, other):
11698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11699 
 
11700 
  def __ne__(self, other):
11701 
    return not (self == other)
11702 
 
11703 
class reshipOrder_result:
11704 
  """
11705 
  Attributes:
11706 
   - success
11707 
   - ex
11708 
  """
11709 
 
11710 
  thrift_spec = (
11711 
    (0, TType.I64, 'success', None, None, ), # 0
11712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11713 
  )
11714 
 
11715 
  def __init__(self, success=None, ex=None,):
11716 
    self.success = success
11717 
    self.ex = ex
11718 
 
11719 
  def read(self, iprot):
11720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11722 
      return
11723 
    iprot.readStructBegin()
11724 
    while True:
11725 
      (fname, ftype, fid) = iprot.readFieldBegin()
11726 
      if ftype == TType.STOP:
11727 
        break
11728 
      if fid == 0:
11729 
        if ftype == TType.I64:
11730 
          self.success = iprot.readI64();
11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      elif fid == 1:
11734 
        if ftype == TType.STRUCT:
11735 
          self.ex = TransactionServiceException()
11736 
          self.ex.read(iprot)
11737 
        else:
11738 
          iprot.skip(ftype)
11739 
      else:
11740 
        iprot.skip(ftype)
11741 
      iprot.readFieldEnd()
11742 
    iprot.readStructEnd()
11743 
 
11744 
  def write(self, oprot):
11745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11747 
      return
11748 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 11749 
    if self.success is not None:
2616 chandransh 11750 
      oprot.writeFieldBegin('success', TType.I64, 0)
11751 
      oprot.writeI64(self.success)
11752 
      oprot.writeFieldEnd()
3431 rajveer 11753 
    if self.ex is not None:
2616 chandransh 11754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11755 
      self.ex.write(oprot)
11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
2616 chandransh 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
11775 
class refundOrder_args:
11776 
  """
11777 
  Attributes:
11778 
   - orderId
3226 chandransh 11779 
   - refundedBy
11780 
   - reason
2616 chandransh 11781 
  """
11782 
 
11783 
  thrift_spec = (
11784 
    None, # 0
11785 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 11786 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
11787 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 11788 
  )
11789 
 
3226 chandransh 11790 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 11791 
    self.orderId = orderId
3226 chandransh 11792 
    self.refundedBy = refundedBy
11793 
    self.reason = reason
2616 chandransh 11794 
 
11795 
  def read(self, iprot):
11796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11798 
      return
11799 
    iprot.readStructBegin()
11800 
    while True:
11801 
      (fname, ftype, fid) = iprot.readFieldBegin()
11802 
      if ftype == TType.STOP:
11803 
        break
11804 
      if fid == 1:
11805 
        if ftype == TType.I64:
11806 
          self.orderId = iprot.readI64();
11807 
        else:
11808 
          iprot.skip(ftype)
3226 chandransh 11809 
      elif fid == 2:
11810 
        if ftype == TType.STRING:
11811 
          self.refundedBy = iprot.readString();
11812 
        else:
11813 
          iprot.skip(ftype)
11814 
      elif fid == 3:
11815 
        if ftype == TType.STRING:
11816 
          self.reason = iprot.readString();
11817 
        else:
11818 
          iprot.skip(ftype)
2616 chandransh 11819 
      else:
11820 
        iprot.skip(ftype)
11821 
      iprot.readFieldEnd()
11822 
    iprot.readStructEnd()
11823 
 
11824 
  def write(self, oprot):
11825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11827 
      return
11828 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 11829 
    if self.orderId is not None:
2616 chandransh 11830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11831 
      oprot.writeI64(self.orderId)
11832 
      oprot.writeFieldEnd()
3431 rajveer 11833 
    if self.refundedBy is not None:
3226 chandransh 11834 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
11835 
      oprot.writeString(self.refundedBy)
11836 
      oprot.writeFieldEnd()
3431 rajveer 11837 
    if self.reason is not None:
3226 chandransh 11838 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
11839 
      oprot.writeString(self.reason)
11840 
      oprot.writeFieldEnd()
2616 chandransh 11841 
    oprot.writeFieldStop()
11842 
    oprot.writeStructEnd()
11843 
 
3431 rajveer 11844 
  def validate(self):
11845 
    return
11846 
 
11847 
 
2616 chandransh 11848 
  def __repr__(self):
11849 
    L = ['%s=%r' % (key, value)
11850 
      for key, value in self.__dict__.iteritems()]
11851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11852 
 
11853 
  def __eq__(self, other):
11854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11855 
 
11856 
  def __ne__(self, other):
11857 
    return not (self == other)
11858 
 
11859 
class refundOrder_result:
11860 
  """
11861 
  Attributes:
11862 
   - success
11863 
   - ex
11864 
  """
11865 
 
11866 
  thrift_spec = (
11867 
    (0, TType.BOOL, 'success', None, None, ), # 0
11868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11869 
  )
11870 
 
11871 
  def __init__(self, success=None, ex=None,):
11872 
    self.success = success
11873 
    self.ex = ex
11874 
 
11875 
  def read(self, iprot):
11876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11878 
      return
11879 
    iprot.readStructBegin()
11880 
    while True:
11881 
      (fname, ftype, fid) = iprot.readFieldBegin()
11882 
      if ftype == TType.STOP:
11883 
        break
11884 
      if fid == 0:
11885 
        if ftype == TType.BOOL:
11886 
          self.success = iprot.readBool();
11887 
        else:
11888 
          iprot.skip(ftype)
11889 
      elif fid == 1:
11890 
        if ftype == TType.STRUCT:
11891 
          self.ex = TransactionServiceException()
11892 
          self.ex.read(iprot)
11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      else:
11896 
        iprot.skip(ftype)
11897 
      iprot.readFieldEnd()
11898 
    iprot.readStructEnd()
11899 
 
11900 
  def write(self, oprot):
11901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11903 
      return
11904 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11905 
    if self.success is not None:
2616 chandransh 11906 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11907 
      oprot.writeBool(self.success)
11908 
      oprot.writeFieldEnd()
3431 rajveer 11909 
    if self.ex is not None:
2616 chandransh 11910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11911 
      self.ex.write(oprot)
11912 
      oprot.writeFieldEnd()
11913 
    oprot.writeFieldStop()
11914 
    oprot.writeStructEnd()
11915 
 
3431 rajveer 11916 
  def validate(self):
11917 
    return
11918 
 
11919 
 
2616 chandransh 11920 
  def __repr__(self):
11921 
    L = ['%s=%r' % (key, value)
11922 
      for key, value in self.__dict__.iteritems()]
11923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11924 
 
11925 
  def __eq__(self, other):
11926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11927 
 
11928 
  def __ne__(self, other):
11929 
    return not (self == other)
11930 
 
2690 chandransh 11931 
class getReturnOrders_args:
11932 
  """
11933 
  Attributes:
11934 
   - warehouseId
11935 
   - fromDate
11936 
   - toDate
11937 
  """
2616 chandransh 11938 
 
2690 chandransh 11939 
  thrift_spec = (
11940 
    None, # 0
11941 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11942 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11943 
    (3, TType.I64, 'toDate', None, None, ), # 3
11944 
  )
11945 
 
11946 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11947 
    self.warehouseId = warehouseId
11948 
    self.fromDate = fromDate
11949 
    self.toDate = toDate
11950 
 
11951 
  def read(self, iprot):
11952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11954 
      return
11955 
    iprot.readStructBegin()
11956 
    while True:
11957 
      (fname, ftype, fid) = iprot.readFieldBegin()
11958 
      if ftype == TType.STOP:
11959 
        break
11960 
      if fid == 1:
11961 
        if ftype == TType.I64:
11962 
          self.warehouseId = iprot.readI64();
11963 
        else:
11964 
          iprot.skip(ftype)
11965 
      elif fid == 2:
11966 
        if ftype == TType.I64:
11967 
          self.fromDate = iprot.readI64();
11968 
        else:
11969 
          iprot.skip(ftype)
11970 
      elif fid == 3:
11971 
        if ftype == TType.I64:
11972 
          self.toDate = iprot.readI64();
11973 
        else:
11974 
          iprot.skip(ftype)
11975 
      else:
11976 
        iprot.skip(ftype)
11977 
      iprot.readFieldEnd()
11978 
    iprot.readStructEnd()
11979 
 
11980 
  def write(self, oprot):
11981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11983 
      return
11984 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11985 
    if self.warehouseId is not None:
2690 chandransh 11986 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11987 
      oprot.writeI64(self.warehouseId)
11988 
      oprot.writeFieldEnd()
3431 rajveer 11989 
    if self.fromDate is not None:
2690 chandransh 11990 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11991 
      oprot.writeI64(self.fromDate)
11992 
      oprot.writeFieldEnd()
3431 rajveer 11993 
    if self.toDate is not None:
2690 chandransh 11994 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11995 
      oprot.writeI64(self.toDate)
11996 
      oprot.writeFieldEnd()
11997 
    oprot.writeFieldStop()
11998 
    oprot.writeStructEnd()
11999 
 
3431 rajveer 12000 
  def validate(self):
12001 
    return
12002 
 
12003 
 
2690 chandransh 12004 
  def __repr__(self):
12005 
    L = ['%s=%r' % (key, value)
12006 
      for key, value in self.__dict__.iteritems()]
12007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12008 
 
12009 
  def __eq__(self, other):
12010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12011 
 
12012 
  def __ne__(self, other):
12013 
    return not (self == other)
12014 
 
12015 
class getReturnOrders_result:
12016 
  """
12017 
  Attributes:
12018 
   - success
12019 
  """
12020 
 
12021 
  thrift_spec = (
12022 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12023 
  )
12024 
 
12025 
  def __init__(self, success=None,):
12026 
    self.success = success
12027 
 
12028 
  def read(self, iprot):
12029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12031 
      return
12032 
    iprot.readStructBegin()
12033 
    while True:
12034 
      (fname, ftype, fid) = iprot.readFieldBegin()
12035 
      if ftype == TType.STOP:
12036 
        break
12037 
      if fid == 0:
12038 
        if ftype == TType.LIST:
12039 
          self.success = []
4133 chandransh 12040 
          (_etype209, _size206) = iprot.readListBegin()
12041 
          for _i210 in xrange(_size206):
12042 
            _elem211 = ReturnOrder()
12043 
            _elem211.read(iprot)
12044 
            self.success.append(_elem211)
2690 chandransh 12045 
          iprot.readListEnd()
12046 
        else:
12047 
          iprot.skip(ftype)
12048 
      else:
12049 
        iprot.skip(ftype)
12050 
      iprot.readFieldEnd()
12051 
    iprot.readStructEnd()
12052 
 
12053 
  def write(self, oprot):
12054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12056 
      return
12057 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12058 
    if self.success is not None:
2690 chandransh 12059 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12060 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12061 
      for iter212 in self.success:
12062 
        iter212.write(oprot)
2690 chandransh 12063 
      oprot.writeListEnd()
12064 
      oprot.writeFieldEnd()
12065 
    oprot.writeFieldStop()
12066 
    oprot.writeStructEnd()
12067 
 
3431 rajveer 12068 
  def validate(self):
12069 
    return
12070 
 
12071 
 
2690 chandransh 12072 
  def __repr__(self):
12073 
    L = ['%s=%r' % (key, value)
12074 
      for key, value in self.__dict__.iteritems()]
12075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12076 
 
12077 
  def __eq__(self, other):
12078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12079 
 
12080 
  def __ne__(self, other):
12081 
    return not (self == other)
12082 
 
2700 chandransh 12083 
class getReturnOrder_args:
12084 
  """
12085 
  Attributes:
12086 
   - id
12087 
  """
12088 
 
12089 
  thrift_spec = (
12090 
    None, # 0
12091 
    (1, TType.I64, 'id', None, None, ), # 1
12092 
  )
12093 
 
12094 
  def __init__(self, id=None,):
12095 
    self.id = id
12096 
 
12097 
  def read(self, iprot):
12098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12100 
      return
12101 
    iprot.readStructBegin()
12102 
    while True:
12103 
      (fname, ftype, fid) = iprot.readFieldBegin()
12104 
      if ftype == TType.STOP:
12105 
        break
12106 
      if fid == 1:
12107 
        if ftype == TType.I64:
12108 
          self.id = iprot.readI64();
12109 
        else:
12110 
          iprot.skip(ftype)
12111 
      else:
12112 
        iprot.skip(ftype)
12113 
      iprot.readFieldEnd()
12114 
    iprot.readStructEnd()
12115 
 
12116 
  def write(self, oprot):
12117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12119 
      return
12120 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 12121 
    if self.id is not None:
2700 chandransh 12122 
      oprot.writeFieldBegin('id', TType.I64, 1)
12123 
      oprot.writeI64(self.id)
12124 
      oprot.writeFieldEnd()
12125 
    oprot.writeFieldStop()
12126 
    oprot.writeStructEnd()
12127 
 
3431 rajveer 12128 
  def validate(self):
12129 
    return
12130 
 
12131 
 
2700 chandransh 12132 
  def __repr__(self):
12133 
    L = ['%s=%r' % (key, value)
12134 
      for key, value in self.__dict__.iteritems()]
12135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12136 
 
12137 
  def __eq__(self, other):
12138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12139 
 
12140 
  def __ne__(self, other):
12141 
    return not (self == other)
12142 
 
12143 
class getReturnOrder_result:
12144 
  """
12145 
  Attributes:
12146 
   - success
12147 
   - ex
12148 
  """
12149 
 
12150 
  thrift_spec = (
12151 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
12152 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12153 
  )
12154 
 
12155 
  def __init__(self, success=None, ex=None,):
12156 
    self.success = success
12157 
    self.ex = ex
12158 
 
12159 
  def read(self, iprot):
12160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12162 
      return
12163 
    iprot.readStructBegin()
12164 
    while True:
12165 
      (fname, ftype, fid) = iprot.readFieldBegin()
12166 
      if ftype == TType.STOP:
12167 
        break
12168 
      if fid == 0:
12169 
        if ftype == TType.STRUCT:
12170 
          self.success = ReturnOrder()
12171 
          self.success.read(iprot)
12172 
        else:
12173 
          iprot.skip(ftype)
12174 
      elif fid == 1:
12175 
        if ftype == TType.STRUCT:
12176 
          self.ex = TransactionServiceException()
12177 
          self.ex.read(iprot)
12178 
        else:
12179 
          iprot.skip(ftype)
12180 
      else:
12181 
        iprot.skip(ftype)
12182 
      iprot.readFieldEnd()
12183 
    iprot.readStructEnd()
12184 
 
12185 
  def write(self, oprot):
12186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12188 
      return
12189 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 12190 
    if self.success is not None:
2700 chandransh 12191 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12192 
      self.success.write(oprot)
12193 
      oprot.writeFieldEnd()
3431 rajveer 12194 
    if self.ex is not None:
2700 chandransh 12195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12196 
      self.ex.write(oprot)
12197 
      oprot.writeFieldEnd()
12198 
    oprot.writeFieldStop()
12199 
    oprot.writeStructEnd()
12200 
 
3431 rajveer 12201 
  def validate(self):
12202 
    return
12203 
 
12204 
 
2700 chandransh 12205 
  def __repr__(self):
12206 
    L = ['%s=%r' % (key, value)
12207 
      for key, value in self.__dict__.iteritems()]
12208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12209 
 
12210 
  def __eq__(self, other):
12211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12212 
 
12213 
  def __ne__(self, other):
12214 
    return not (self == other)
12215 
 
2690 chandransh 12216 
class processReturn_args:
12217 
  """
12218 
  Attributes:
12219 
   - returnOrderId
12220 
  """
12221 
 
12222 
  thrift_spec = (
12223 
    None, # 0
12224 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
12225 
  )
12226 
 
12227 
  def __init__(self, returnOrderId=None,):
12228 
    self.returnOrderId = returnOrderId
12229 
 
12230 
  def read(self, iprot):
12231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12233 
      return
12234 
    iprot.readStructBegin()
12235 
    while True:
12236 
      (fname, ftype, fid) = iprot.readFieldBegin()
12237 
      if ftype == TType.STOP:
12238 
        break
12239 
      if fid == 1:
12240 
        if ftype == TType.I64:
12241 
          self.returnOrderId = iprot.readI64();
12242 
        else:
12243 
          iprot.skip(ftype)
12244 
      else:
12245 
        iprot.skip(ftype)
12246 
      iprot.readFieldEnd()
12247 
    iprot.readStructEnd()
12248 
 
12249 
  def write(self, oprot):
12250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12252 
      return
12253 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 12254 
    if self.returnOrderId is not None:
2690 chandransh 12255 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
12256 
      oprot.writeI64(self.returnOrderId)
12257 
      oprot.writeFieldEnd()
12258 
    oprot.writeFieldStop()
12259 
    oprot.writeStructEnd()
12260 
 
3431 rajveer 12261 
  def validate(self):
12262 
    return
12263 
 
12264 
 
2690 chandransh 12265 
  def __repr__(self):
12266 
    L = ['%s=%r' % (key, value)
12267 
      for key, value in self.__dict__.iteritems()]
12268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12269 
 
12270 
  def __eq__(self, other):
12271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12272 
 
12273 
  def __ne__(self, other):
12274 
    return not (self == other)
12275 
 
12276 
class processReturn_result:
12277 
  """
12278 
  Attributes:
12279 
   - ex
12280 
  """
12281 
 
12282 
  thrift_spec = (
12283 
    None, # 0
12284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12285 
  )
12286 
 
12287 
  def __init__(self, ex=None,):
12288 
    self.ex = ex
12289 
 
12290 
  def read(self, iprot):
12291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12293 
      return
12294 
    iprot.readStructBegin()
12295 
    while True:
12296 
      (fname, ftype, fid) = iprot.readFieldBegin()
12297 
      if ftype == TType.STOP:
12298 
        break
12299 
      if fid == 1:
12300 
        if ftype == TType.STRUCT:
12301 
          self.ex = TransactionServiceException()
12302 
          self.ex.read(iprot)
12303 
        else:
12304 
          iprot.skip(ftype)
12305 
      else:
12306 
        iprot.skip(ftype)
12307 
      iprot.readFieldEnd()
12308 
    iprot.readStructEnd()
12309 
 
12310 
  def write(self, oprot):
12311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12313 
      return
12314 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 12315 
    if self.ex is not None:
2690 chandransh 12316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12317 
      self.ex.write(oprot)
12318 
      oprot.writeFieldEnd()
12319 
    oprot.writeFieldStop()
12320 
    oprot.writeStructEnd()
12321 
 
3431 rajveer 12322 
  def validate(self):
12323 
    return
12324 
 
12325 
 
2690 chandransh 12326 
  def __repr__(self):
12327 
    L = ['%s=%r' % (key, value)
12328 
      for key, value in self.__dict__.iteritems()]
12329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12330 
 
12331 
  def __eq__(self, other):
12332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12333 
 
12334 
  def __ne__(self, other):
12335 
    return not (self == other)
12336 
 
2819 chandransh 12337 
class createPurchaseOrder_args:
12338 
  """
12339 
  Attributes:
12340 
   - warehouseId
12341 
  """
2690 chandransh 12342 
 
2819 chandransh 12343 
  thrift_spec = (
12344 
    None, # 0
12345 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12346 
  )
12347 
 
12348 
  def __init__(self, warehouseId=None,):
12349 
    self.warehouseId = warehouseId
12350 
 
12351 
  def read(self, iprot):
12352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12354 
      return
12355 
    iprot.readStructBegin()
12356 
    while True:
12357 
      (fname, ftype, fid) = iprot.readFieldBegin()
12358 
      if ftype == TType.STOP:
12359 
        break
12360 
      if fid == 1:
12361 
        if ftype == TType.I64:
12362 
          self.warehouseId = iprot.readI64();
12363 
        else:
12364 
          iprot.skip(ftype)
12365 
      else:
12366 
        iprot.skip(ftype)
12367 
      iprot.readFieldEnd()
12368 
    iprot.readStructEnd()
12369 
 
12370 
  def write(self, oprot):
12371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12373 
      return
12374 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 12375 
    if self.warehouseId is not None:
2819 chandransh 12376 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12377 
      oprot.writeI64(self.warehouseId)
12378 
      oprot.writeFieldEnd()
12379 
    oprot.writeFieldStop()
12380 
    oprot.writeStructEnd()
12381 
 
3431 rajveer 12382 
  def validate(self):
12383 
    return
12384 
 
12385 
 
2819 chandransh 12386 
  def __repr__(self):
12387 
    L = ['%s=%r' % (key, value)
12388 
      for key, value in self.__dict__.iteritems()]
12389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12390 
 
12391 
  def __eq__(self, other):
12392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12393 
 
12394 
  def __ne__(self, other):
12395 
    return not (self == other)
12396 
 
12397 
class createPurchaseOrder_result:
12398 
  """
12399 
  Attributes:
12400 
   - success
12401 
   - ex
12402 
  """
12403 
 
12404 
  thrift_spec = (
12405 
    (0, TType.I64, 'success', None, None, ), # 0
12406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12407 
  )
12408 
 
12409 
  def __init__(self, success=None, ex=None,):
12410 
    self.success = success
12411 
    self.ex = ex
12412 
 
12413 
  def read(self, iprot):
12414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12416 
      return
12417 
    iprot.readStructBegin()
12418 
    while True:
12419 
      (fname, ftype, fid) = iprot.readFieldBegin()
12420 
      if ftype == TType.STOP:
12421 
        break
12422 
      if fid == 0:
12423 
        if ftype == TType.I64:
12424 
          self.success = iprot.readI64();
12425 
        else:
12426 
          iprot.skip(ftype)
12427 
      elif fid == 1:
12428 
        if ftype == TType.STRUCT:
12429 
          self.ex = TransactionServiceException()
12430 
          self.ex.read(iprot)
12431 
        else:
12432 
          iprot.skip(ftype)
12433 
      else:
12434 
        iprot.skip(ftype)
12435 
      iprot.readFieldEnd()
12436 
    iprot.readStructEnd()
12437 
 
12438 
  def write(self, oprot):
12439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12441 
      return
12442 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 12443 
    if self.success is not None:
2819 chandransh 12444 
      oprot.writeFieldBegin('success', TType.I64, 0)
12445 
      oprot.writeI64(self.success)
12446 
      oprot.writeFieldEnd()
3431 rajveer 12447 
    if self.ex is not None:
2819 chandransh 12448 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12449 
      self.ex.write(oprot)
12450 
      oprot.writeFieldEnd()
12451 
    oprot.writeFieldStop()
12452 
    oprot.writeStructEnd()
12453 
 
3431 rajveer 12454 
  def validate(self):
12455 
    return
12456 
 
12457 
 
2819 chandransh 12458 
  def __repr__(self):
12459 
    L = ['%s=%r' % (key, value)
12460 
      for key, value in self.__dict__.iteritems()]
12461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12462 
 
12463 
  def __eq__(self, other):
12464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12465 
 
12466 
  def __ne__(self, other):
12467 
    return not (self == other)
3451 chandransh 12468 
 
12469 
class updateWeight_args:
12470 
  """
12471 
  Attributes:
12472 
   - orderId
12473 
   - weight
12474 
  """
12475 
 
12476 
  thrift_spec = (
12477 
    None, # 0
12478 
    (1, TType.I64, 'orderId', None, None, ), # 1
12479 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
12480 
  )
12481 
 
12482 
  def __init__(self, orderId=None, weight=None,):
12483 
    self.orderId = orderId
12484 
    self.weight = weight
12485 
 
12486 
  def read(self, iprot):
12487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12489 
      return
12490 
    iprot.readStructBegin()
12491 
    while True:
12492 
      (fname, ftype, fid) = iprot.readFieldBegin()
12493 
      if ftype == TType.STOP:
12494 
        break
12495 
      if fid == 1:
12496 
        if ftype == TType.I64:
12497 
          self.orderId = iprot.readI64();
12498 
        else:
12499 
          iprot.skip(ftype)
12500 
      elif fid == 2:
12501 
        if ftype == TType.DOUBLE:
12502 
          self.weight = iprot.readDouble();
12503 
        else:
12504 
          iprot.skip(ftype)
12505 
      else:
12506 
        iprot.skip(ftype)
12507 
      iprot.readFieldEnd()
12508 
    iprot.readStructEnd()
12509 
 
12510 
  def write(self, oprot):
12511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12513 
      return
12514 
    oprot.writeStructBegin('updateWeight_args')
12515 
    if self.orderId is not None:
12516 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12517 
      oprot.writeI64(self.orderId)
12518 
      oprot.writeFieldEnd()
12519 
    if self.weight is not None:
12520 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
12521 
      oprot.writeDouble(self.weight)
12522 
      oprot.writeFieldEnd()
12523 
    oprot.writeFieldStop()
12524 
    oprot.writeStructEnd()
12525 
 
12526 
  def validate(self):
12527 
    return
12528 
 
12529 
 
12530 
  def __repr__(self):
12531 
    L = ['%s=%r' % (key, value)
12532 
      for key, value in self.__dict__.iteritems()]
12533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12534 
 
12535 
  def __eq__(self, other):
12536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12537 
 
12538 
  def __ne__(self, other):
12539 
    return not (self == other)
12540 
 
12541 
class updateWeight_result:
12542 
  """
12543 
  Attributes:
12544 
   - success
12545 
   - ex
12546 
  """
12547 
 
12548 
  thrift_spec = (
12549 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12551 
  )
12552 
 
12553 
  def __init__(self, success=None, ex=None,):
12554 
    self.success = success
12555 
    self.ex = ex
12556 
 
12557 
  def read(self, iprot):
12558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12560 
      return
12561 
    iprot.readStructBegin()
12562 
    while True:
12563 
      (fname, ftype, fid) = iprot.readFieldBegin()
12564 
      if ftype == TType.STOP:
12565 
        break
12566 
      if fid == 0:
12567 
        if ftype == TType.STRUCT:
12568 
          self.success = Order()
12569 
          self.success.read(iprot)
12570 
        else:
12571 
          iprot.skip(ftype)
12572 
      elif fid == 1:
12573 
        if ftype == TType.STRUCT:
12574 
          self.ex = TransactionServiceException()
12575 
          self.ex.read(iprot)
12576 
        else:
12577 
          iprot.skip(ftype)
12578 
      else:
12579 
        iprot.skip(ftype)
12580 
      iprot.readFieldEnd()
12581 
    iprot.readStructEnd()
12582 
 
12583 
  def write(self, oprot):
12584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12586 
      return
12587 
    oprot.writeStructBegin('updateWeight_result')
12588 
    if self.success is not None:
12589 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12590 
      self.success.write(oprot)
12591 
      oprot.writeFieldEnd()
12592 
    if self.ex is not None:
12593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12594 
      self.ex.write(oprot)
12595 
      oprot.writeFieldEnd()
12596 
    oprot.writeFieldStop()
12597 
    oprot.writeStructEnd()
12598 
 
12599 
  def validate(self):
12600 
    return
12601 
 
12602 
 
12603 
  def __repr__(self):
12604 
    L = ['%s=%r' % (key, value)
12605 
      for key, value in self.__dict__.iteritems()]
12606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12607 
 
12608 
  def __eq__(self, other):
12609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12610 
 
12611 
  def __ne__(self, other):
12612 
    return not (self == other)
3469 chandransh 12613 
 
12614 
class changeItem_args:
12615 
  """
12616 
  Attributes:
12617 
   - orderId
12618 
   - itemId
12619 
  """
12620 
 
12621 
  thrift_spec = (
12622 
    None, # 0
12623 
    (1, TType.I64, 'orderId', None, None, ), # 1
12624 
    (2, TType.I64, 'itemId', None, None, ), # 2
12625 
  )
12626 
 
12627 
  def __init__(self, orderId=None, itemId=None,):
12628 
    self.orderId = orderId
12629 
    self.itemId = itemId
12630 
 
12631 
  def read(self, iprot):
12632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12634 
      return
12635 
    iprot.readStructBegin()
12636 
    while True:
12637 
      (fname, ftype, fid) = iprot.readFieldBegin()
12638 
      if ftype == TType.STOP:
12639 
        break
12640 
      if fid == 1:
12641 
        if ftype == TType.I64:
12642 
          self.orderId = iprot.readI64();
12643 
        else:
12644 
          iprot.skip(ftype)
12645 
      elif fid == 2:
12646 
        if ftype == TType.I64:
12647 
          self.itemId = iprot.readI64();
12648 
        else:
12649 
          iprot.skip(ftype)
12650 
      else:
12651 
        iprot.skip(ftype)
12652 
      iprot.readFieldEnd()
12653 
    iprot.readStructEnd()
12654 
 
12655 
  def write(self, oprot):
12656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12658 
      return
12659 
    oprot.writeStructBegin('changeItem_args')
12660 
    if self.orderId is not None:
12661 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12662 
      oprot.writeI64(self.orderId)
12663 
      oprot.writeFieldEnd()
12664 
    if self.itemId is not None:
12665 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12666 
      oprot.writeI64(self.itemId)
12667 
      oprot.writeFieldEnd()
12668 
    oprot.writeFieldStop()
12669 
    oprot.writeStructEnd()
12670 
 
12671 
  def validate(self):
12672 
    return
12673 
 
12674 
 
12675 
  def __repr__(self):
12676 
    L = ['%s=%r' % (key, value)
12677 
      for key, value in self.__dict__.iteritems()]
12678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12679 
 
12680 
  def __eq__(self, other):
12681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12682 
 
12683 
  def __ne__(self, other):
12684 
    return not (self == other)
12685 
 
12686 
class changeItem_result:
12687 
  """
12688 
  Attributes:
12689 
   - success
12690 
   - ex
12691 
  """
12692 
 
12693 
  thrift_spec = (
12694 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12695 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12696 
  )
12697 
 
12698 
  def __init__(self, success=None, ex=None,):
12699 
    self.success = success
12700 
    self.ex = ex
12701 
 
12702 
  def read(self, iprot):
12703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12705 
      return
12706 
    iprot.readStructBegin()
12707 
    while True:
12708 
      (fname, ftype, fid) = iprot.readFieldBegin()
12709 
      if ftype == TType.STOP:
12710 
        break
12711 
      if fid == 0:
12712 
        if ftype == TType.STRUCT:
12713 
          self.success = Order()
12714 
          self.success.read(iprot)
12715 
        else:
12716 
          iprot.skip(ftype)
12717 
      elif fid == 1:
12718 
        if ftype == TType.STRUCT:
12719 
          self.ex = TransactionServiceException()
12720 
          self.ex.read(iprot)
12721 
        else:
12722 
          iprot.skip(ftype)
12723 
      else:
12724 
        iprot.skip(ftype)
12725 
      iprot.readFieldEnd()
12726 
    iprot.readStructEnd()
12727 
 
12728 
  def write(self, oprot):
12729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12731 
      return
12732 
    oprot.writeStructBegin('changeItem_result')
12733 
    if self.success is not None:
12734 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12735 
      self.success.write(oprot)
12736 
      oprot.writeFieldEnd()
12737 
    if self.ex is not None:
12738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12739 
      self.ex.write(oprot)
12740 
      oprot.writeFieldEnd()
12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
12744 
  def validate(self):
12745 
    return
12746 
 
12747 
 
12748 
  def __repr__(self):
12749 
    L = ['%s=%r' % (key, value)
12750 
      for key, value in self.__dict__.iteritems()]
12751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12752 
 
12753 
  def __eq__(self, other):
12754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12755 
 
12756 
  def __ne__(self, other):
12757 
    return not (self == other)
12758 
 
12759 
class shiftToWarehouse_args:
12760 
  """
12761 
  Attributes:
12762 
   - orderId
12763 
   - warehouseId
12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    None, # 0
12768 
    (1, TType.I64, 'orderId', None, None, ), # 1
12769 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12770 
  )
12771 
 
12772 
  def __init__(self, orderId=None, warehouseId=None,):
12773 
    self.orderId = orderId
12774 
    self.warehouseId = warehouseId
12775 
 
12776 
  def read(self, iprot):
12777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12779 
      return
12780 
    iprot.readStructBegin()
12781 
    while True:
12782 
      (fname, ftype, fid) = iprot.readFieldBegin()
12783 
      if ftype == TType.STOP:
12784 
        break
12785 
      if fid == 1:
12786 
        if ftype == TType.I64:
12787 
          self.orderId = iprot.readI64();
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 2:
12791 
        if ftype == TType.I64:
12792 
          self.warehouseId = iprot.readI64();
12793 
        else:
12794 
          iprot.skip(ftype)
12795 
      else:
12796 
        iprot.skip(ftype)
12797 
      iprot.readFieldEnd()
12798 
    iprot.readStructEnd()
12799 
 
12800 
  def write(self, oprot):
12801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12803 
      return
12804 
    oprot.writeStructBegin('shiftToWarehouse_args')
12805 
    if self.orderId is not None:
12806 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12807 
      oprot.writeI64(self.orderId)
12808 
      oprot.writeFieldEnd()
12809 
    if self.warehouseId is not None:
12810 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12811 
      oprot.writeI64(self.warehouseId)
12812 
      oprot.writeFieldEnd()
12813 
    oprot.writeFieldStop()
12814 
    oprot.writeStructEnd()
12815 
 
12816 
  def validate(self):
12817 
    return
12818 
 
12819 
 
12820 
  def __repr__(self):
12821 
    L = ['%s=%r' % (key, value)
12822 
      for key, value in self.__dict__.iteritems()]
12823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12824 
 
12825 
  def __eq__(self, other):
12826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12827 
 
12828 
  def __ne__(self, other):
12829 
    return not (self == other)
12830 
 
12831 
class shiftToWarehouse_result:
12832 
  """
12833 
  Attributes:
12834 
   - success
12835 
   - ex
12836 
  """
12837 
 
12838 
  thrift_spec = (
12839 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12841 
  )
12842 
 
12843 
  def __init__(self, success=None, ex=None,):
12844 
    self.success = success
12845 
    self.ex = ex
12846 
 
12847 
  def read(self, iprot):
12848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12850 
      return
12851 
    iprot.readStructBegin()
12852 
    while True:
12853 
      (fname, ftype, fid) = iprot.readFieldBegin()
12854 
      if ftype == TType.STOP:
12855 
        break
12856 
      if fid == 0:
12857 
        if ftype == TType.STRUCT:
12858 
          self.success = Order()
12859 
          self.success.read(iprot)
12860 
        else:
12861 
          iprot.skip(ftype)
12862 
      elif fid == 1:
12863 
        if ftype == TType.STRUCT:
12864 
          self.ex = TransactionServiceException()
12865 
          self.ex.read(iprot)
12866 
        else:
12867 
          iprot.skip(ftype)
12868 
      else:
12869 
        iprot.skip(ftype)
12870 
      iprot.readFieldEnd()
12871 
    iprot.readStructEnd()
12872 
 
12873 
  def write(self, oprot):
12874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12876 
      return
12877 
    oprot.writeStructBegin('shiftToWarehouse_result')
12878 
    if self.success is not None:
12879 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12880 
      self.success.write(oprot)
12881 
      oprot.writeFieldEnd()
12882 
    if self.ex is not None:
12883 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12884 
      self.ex.write(oprot)
12885 
      oprot.writeFieldEnd()
12886 
    oprot.writeFieldStop()
12887 
    oprot.writeStructEnd()
12888 
 
12889 
  def validate(self):
12890 
    return
12891 
 
12892 
 
12893 
  def __repr__(self):
12894 
    L = ['%s=%r' % (key, value)
12895 
      for key, value in self.__dict__.iteritems()]
12896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12897 
 
12898 
  def __eq__(self, other):
12899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12900 
 
12901 
  def __ne__(self, other):
12902 
    return not (self == other)
3553 chandransh 12903 
 
12904 
class addDelayReason_args:
12905 
  """
12906 
  Attributes:
12907 
   - orderId
12908 
   - delayReason
3986 chandransh 12909 
   - furtherDelay
3553 chandransh 12910 
  """
12911 
 
12912 
  thrift_spec = (
12913 
    None, # 0
12914 
    (1, TType.I64, 'orderId', None, None, ), # 1
12915 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12916 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12917 
  )
12918 
 
3986 chandransh 12919 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12920 
    self.orderId = orderId
12921 
    self.delayReason = delayReason
3986 chandransh 12922 
    self.furtherDelay = furtherDelay
3553 chandransh 12923 
 
12924 
  def read(self, iprot):
12925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12927 
      return
12928 
    iprot.readStructBegin()
12929 
    while True:
12930 
      (fname, ftype, fid) = iprot.readFieldBegin()
12931 
      if ftype == TType.STOP:
12932 
        break
12933 
      if fid == 1:
12934 
        if ftype == TType.I64:
12935 
          self.orderId = iprot.readI64();
12936 
        else:
12937 
          iprot.skip(ftype)
12938 
      elif fid == 2:
12939 
        if ftype == TType.I32:
12940 
          self.delayReason = iprot.readI32();
12941 
        else:
12942 
          iprot.skip(ftype)
3986 chandransh 12943 
      elif fid == 3:
12944 
        if ftype == TType.I64:
12945 
          self.furtherDelay = iprot.readI64();
12946 
        else:
12947 
          iprot.skip(ftype)
3553 chandransh 12948 
      else:
12949 
        iprot.skip(ftype)
12950 
      iprot.readFieldEnd()
12951 
    iprot.readStructEnd()
12952 
 
12953 
  def write(self, oprot):
12954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12956 
      return
12957 
    oprot.writeStructBegin('addDelayReason_args')
12958 
    if self.orderId is not None:
12959 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12960 
      oprot.writeI64(self.orderId)
12961 
      oprot.writeFieldEnd()
12962 
    if self.delayReason is not None:
12963 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12964 
      oprot.writeI32(self.delayReason)
12965 
      oprot.writeFieldEnd()
3986 chandransh 12966 
    if self.furtherDelay is not None:
12967 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12968 
      oprot.writeI64(self.furtherDelay)
12969 
      oprot.writeFieldEnd()
3553 chandransh 12970 
    oprot.writeFieldStop()
12971 
    oprot.writeStructEnd()
12972 
 
12973 
  def validate(self):
12974 
    return
12975 
 
12976 
 
12977 
  def __repr__(self):
12978 
    L = ['%s=%r' % (key, value)
12979 
      for key, value in self.__dict__.iteritems()]
12980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12981 
 
12982 
  def __eq__(self, other):
12983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12984 
 
12985 
  def __ne__(self, other):
12986 
    return not (self == other)
12987 
 
12988 
class addDelayReason_result:
12989 
  """
12990 
  Attributes:
12991 
   - success
12992 
   - ex
12993 
  """
12994 
 
12995 
  thrift_spec = (
12996 
    (0, TType.BOOL, 'success', None, None, ), # 0
12997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12998 
  )
12999 
 
13000 
  def __init__(self, success=None, ex=None,):
13001 
    self.success = success
13002 
    self.ex = ex
13003 
 
13004 
  def read(self, iprot):
13005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13007 
      return
13008 
    iprot.readStructBegin()
13009 
    while True:
13010 
      (fname, ftype, fid) = iprot.readFieldBegin()
13011 
      if ftype == TType.STOP:
13012 
        break
13013 
      if fid == 0:
13014 
        if ftype == TType.BOOL:
13015 
          self.success = iprot.readBool();
13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      elif fid == 1:
13019 
        if ftype == TType.STRUCT:
13020 
          self.ex = TransactionServiceException()
13021 
          self.ex.read(iprot)
13022 
        else:
13023 
          iprot.skip(ftype)
13024 
      else:
13025 
        iprot.skip(ftype)
13026 
      iprot.readFieldEnd()
13027 
    iprot.readStructEnd()
13028 
 
13029 
  def write(self, oprot):
13030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13032 
      return
13033 
    oprot.writeStructBegin('addDelayReason_result')
13034 
    if self.success is not None:
13035 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13036 
      oprot.writeBool(self.success)
13037 
      oprot.writeFieldEnd()
13038 
    if self.ex is not None:
13039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13040 
      self.ex.write(oprot)
13041 
      oprot.writeFieldEnd()
13042 
    oprot.writeFieldStop()
13043 
    oprot.writeStructEnd()
13044 
 
13045 
  def validate(self):
13046 
    return
13047 
 
13048 
 
13049 
  def __repr__(self):
13050 
    L = ['%s=%r' % (key, value)
13051 
      for key, value in self.__dict__.iteritems()]
13052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13053 
 
13054 
  def __eq__(self, other):
13055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13056 
 
13057 
  def __ne__(self, other):
13058 
    return not (self == other)
3956 chandransh 13059 
 
13060 
class reconcileCodCollection_args:
13061 
  """
13062 
  Attributes:
13063 
   - collectedAmountMap
13064 
   - xferBy
13065 
   - xferTxnId
13066 
   - xferDate
13067 
  """
13068 
 
13069 
  thrift_spec = (
13070 
    None, # 0
13071 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13072 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13073 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13074 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13075 
  )
13076 
 
13077 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13078 
    self.collectedAmountMap = collectedAmountMap
13079 
    self.xferBy = xferBy
13080 
    self.xferTxnId = xferTxnId
13081 
    self.xferDate = xferDate
13082 
 
13083 
  def read(self, iprot):
13084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13086 
      return
13087 
    iprot.readStructBegin()
13088 
    while True:
13089 
      (fname, ftype, fid) = iprot.readFieldBegin()
13090 
      if ftype == TType.STOP:
13091 
        break
13092 
      if fid == 1:
13093 
        if ftype == TType.MAP:
13094 
          self.collectedAmountMap = {}
4133 chandransh 13095 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13096 
          for _i217 in xrange(_size213):
13097 
            _key218 = iprot.readString();
13098 
            _val219 = iprot.readDouble();
13099 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 13100 
          iprot.readMapEnd()
13101 
        else:
13102 
          iprot.skip(ftype)
13103 
      elif fid == 2:
13104 
        if ftype == TType.STRING:
13105 
          self.xferBy = iprot.readString();
13106 
        else:
13107 
          iprot.skip(ftype)
13108 
      elif fid == 3:
13109 
        if ftype == TType.STRING:
13110 
          self.xferTxnId = iprot.readString();
13111 
        else:
13112 
          iprot.skip(ftype)
13113 
      elif fid == 4:
13114 
        if ftype == TType.I64:
13115 
          self.xferDate = iprot.readI64();
13116 
        else:
13117 
          iprot.skip(ftype)
13118 
      else:
13119 
        iprot.skip(ftype)
13120 
      iprot.readFieldEnd()
13121 
    iprot.readStructEnd()
13122 
 
13123 
  def write(self, oprot):
13124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13126 
      return
13127 
    oprot.writeStructBegin('reconcileCodCollection_args')
13128 
    if self.collectedAmountMap is not None:
13129 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
13130 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 13131 
      for kiter220,viter221 in self.collectedAmountMap.items():
13132 
        oprot.writeString(kiter220)
13133 
        oprot.writeDouble(viter221)
3956 chandransh 13134 
      oprot.writeMapEnd()
13135 
      oprot.writeFieldEnd()
13136 
    if self.xferBy is not None:
13137 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
13138 
      oprot.writeString(self.xferBy)
13139 
      oprot.writeFieldEnd()
13140 
    if self.xferTxnId is not None:
13141 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
13142 
      oprot.writeString(self.xferTxnId)
13143 
      oprot.writeFieldEnd()
13144 
    if self.xferDate is not None:
13145 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
13146 
      oprot.writeI64(self.xferDate)
13147 
      oprot.writeFieldEnd()
13148 
    oprot.writeFieldStop()
13149 
    oprot.writeStructEnd()
13150 
 
13151 
  def validate(self):
13152 
    return
13153 
 
13154 
 
13155 
  def __repr__(self):
13156 
    L = ['%s=%r' % (key, value)
13157 
      for key, value in self.__dict__.iteritems()]
13158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13159 
 
13160 
  def __eq__(self, other):
13161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13162 
 
13163 
  def __ne__(self, other):
13164 
    return not (self == other)
13165 
 
13166 
class reconcileCodCollection_result:
13167 
  """
13168 
  Attributes:
13169 
   - success
13170 
   - ex
13171 
  """
13172 
 
13173 
  thrift_spec = (
13174 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
13175 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13176 
  )
13177 
 
13178 
  def __init__(self, success=None, ex=None,):
13179 
    self.success = success
13180 
    self.ex = ex
13181 
 
13182 
  def read(self, iprot):
13183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13185 
      return
13186 
    iprot.readStructBegin()
13187 
    while True:
13188 
      (fname, ftype, fid) = iprot.readFieldBegin()
13189 
      if ftype == TType.STOP:
13190 
        break
13191 
      if fid == 0:
13192 
        if ftype == TType.MAP:
13193 
          self.success = {}
4133 chandransh 13194 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
13195 
          for _i226 in xrange(_size222):
13196 
            _key227 = iprot.readString();
13197 
            _val228 = iprot.readString();
13198 
            self.success[_key227] = _val228
3956 chandransh 13199 
          iprot.readMapEnd()
13200 
        else:
13201 
          iprot.skip(ftype)
13202 
      elif fid == 1:
13203 
        if ftype == TType.STRUCT:
13204 
          self.ex = TransactionServiceException()
13205 
          self.ex.read(iprot)
13206 
        else:
13207 
          iprot.skip(ftype)
13208 
      else:
13209 
        iprot.skip(ftype)
13210 
      iprot.readFieldEnd()
13211 
    iprot.readStructEnd()
13212 
 
13213 
  def write(self, oprot):
13214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13216 
      return
13217 
    oprot.writeStructBegin('reconcileCodCollection_result')
13218 
    if self.success is not None:
13219 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13220 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 13221 
      for kiter229,viter230 in self.success.items():
13222 
        oprot.writeString(kiter229)
13223 
        oprot.writeString(viter230)
3956 chandransh 13224 
      oprot.writeMapEnd()
13225 
      oprot.writeFieldEnd()
13226 
    if self.ex is not None:
13227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13228 
      self.ex.write(oprot)
13229 
      oprot.writeFieldEnd()
13230 
    oprot.writeFieldStop()
13231 
    oprot.writeStructEnd()
13232 
 
13233 
  def validate(self):
13234 
    return
13235 
 
13236 
 
13237 
  def __repr__(self):
13238 
    L = ['%s=%r' % (key, value)
13239 
      for key, value in self.__dict__.iteritems()]
13240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13241 
 
13242 
  def __eq__(self, other):
13243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13244 
 
13245 
  def __ne__(self, other):
13246 
    return not (self == other)
4008 mandeep.dh 13247 
 
13248 
class getTransactionsRequiringExtraProcessing_args:
13249 
  """
13250 
  Attributes:
13251 
   - category
13252 
  """
13253 
 
13254 
  thrift_spec = (
13255 
    None, # 0
13256 
    (1, TType.I32, 'category', None, None, ), # 1
13257 
  )
13258 
 
13259 
  def __init__(self, category=None,):
13260 
    self.category = category
13261 
 
13262 
  def read(self, iprot):
13263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13265 
      return
13266 
    iprot.readStructBegin()
13267 
    while True:
13268 
      (fname, ftype, fid) = iprot.readFieldBegin()
13269 
      if ftype == TType.STOP:
13270 
        break
13271 
      if fid == 1:
13272 
        if ftype == TType.I32:
13273 
          self.category = iprot.readI32();
13274 
        else:
13275 
          iprot.skip(ftype)
13276 
      else:
13277 
        iprot.skip(ftype)
13278 
      iprot.readFieldEnd()
13279 
    iprot.readStructEnd()
13280 
 
13281 
  def write(self, oprot):
13282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13284 
      return
13285 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
13286 
    if self.category is not None:
13287 
      oprot.writeFieldBegin('category', TType.I32, 1)
13288 
      oprot.writeI32(self.category)
13289 
      oprot.writeFieldEnd()
13290 
    oprot.writeFieldStop()
13291 
    oprot.writeStructEnd()
13292 
 
13293 
  def validate(self):
13294 
    return
13295 
 
13296 
 
13297 
  def __repr__(self):
13298 
    L = ['%s=%r' % (key, value)
13299 
      for key, value in self.__dict__.iteritems()]
13300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13301 
 
13302 
  def __eq__(self, other):
13303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13304 
 
13305 
  def __ne__(self, other):
13306 
    return not (self == other)
13307 
 
13308 
class getTransactionsRequiringExtraProcessing_result:
13309 
  """
13310 
  Attributes:
13311 
   - success
13312 
  """
13313 
 
13314 
  thrift_spec = (
13315 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13316 
  )
13317 
 
13318 
  def __init__(self, success=None,):
13319 
    self.success = success
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 == 0:
13331 
        if ftype == TType.LIST:
13332 
          self.success = []
4133 chandransh 13333 
          (_etype234, _size231) = iprot.readListBegin()
13334 
          for _i235 in xrange(_size231):
13335 
            _elem236 = iprot.readI64();
13336 
            self.success.append(_elem236)
4008 mandeep.dh 13337 
          iprot.readListEnd()
13338 
        else:
13339 
          iprot.skip(ftype)
13340 
      else:
13341 
        iprot.skip(ftype)
13342 
      iprot.readFieldEnd()
13343 
    iprot.readStructEnd()
13344 
 
13345 
  def write(self, oprot):
13346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13348 
      return
13349 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
13350 
    if self.success is not None:
13351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13352 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 13353 
      for iter237 in self.success:
13354 
        oprot.writeI64(iter237)
4008 mandeep.dh 13355 
      oprot.writeListEnd()
13356 
      oprot.writeFieldEnd()
13357 
    oprot.writeFieldStop()
13358 
    oprot.writeStructEnd()
13359 
 
13360 
  def validate(self):
13361 
    return
13362 
 
13363 
 
13364 
  def __repr__(self):
13365 
    L = ['%s=%r' % (key, value)
13366 
      for key, value in self.__dict__.iteritems()]
13367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13368 
 
13369 
  def __eq__(self, other):
13370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13371 
 
13372 
  def __ne__(self, other):
13373 
    return not (self == other)
13374 
 
13375 
class markTransactionAsProcessed_args:
13376 
  """
13377 
  Attributes:
13378 
   - transactionId
13379 
   - category
13380 
  """
13381 
 
13382 
  thrift_spec = (
13383 
    None, # 0
13384 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13385 
    (2, TType.I32, 'category', None, None, ), # 2
13386 
  )
13387 
 
13388 
  def __init__(self, transactionId=None, category=None,):
13389 
    self.transactionId = transactionId
13390 
    self.category = category
13391 
 
13392 
  def read(self, iprot):
13393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13395 
      return
13396 
    iprot.readStructBegin()
13397 
    while True:
13398 
      (fname, ftype, fid) = iprot.readFieldBegin()
13399 
      if ftype == TType.STOP:
13400 
        break
13401 
      if fid == 1:
13402 
        if ftype == TType.I64:
13403 
          self.transactionId = iprot.readI64();
13404 
        else:
13405 
          iprot.skip(ftype)
13406 
      elif fid == 2:
13407 
        if ftype == TType.I32:
13408 
          self.category = iprot.readI32();
13409 
        else:
13410 
          iprot.skip(ftype)
13411 
      else:
13412 
        iprot.skip(ftype)
13413 
      iprot.readFieldEnd()
13414 
    iprot.readStructEnd()
13415 
 
13416 
  def write(self, oprot):
13417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13419 
      return
13420 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
13421 
    if self.transactionId is not None:
13422 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13423 
      oprot.writeI64(self.transactionId)
13424 
      oprot.writeFieldEnd()
13425 
    if self.category is not None:
13426 
      oprot.writeFieldBegin('category', TType.I32, 2)
13427 
      oprot.writeI32(self.category)
13428 
      oprot.writeFieldEnd()
13429 
    oprot.writeFieldStop()
13430 
    oprot.writeStructEnd()
13431 
 
13432 
  def validate(self):
13433 
    return
13434 
 
13435 
 
13436 
  def __repr__(self):
13437 
    L = ['%s=%r' % (key, value)
13438 
      for key, value in self.__dict__.iteritems()]
13439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13440 
 
13441 
  def __eq__(self, other):
13442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13443 
 
13444 
  def __ne__(self, other):
13445 
    return not (self == other)
13446 
 
13447 
class markTransactionAsProcessed_result:
13448 
 
13449 
  thrift_spec = (
13450 
  )
13451 
 
13452 
  def read(self, iprot):
13453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13455 
      return
13456 
    iprot.readStructBegin()
13457 
    while True:
13458 
      (fname, ftype, fid) = iprot.readFieldBegin()
13459 
      if ftype == TType.STOP:
13460 
        break
13461 
      else:
13462 
        iprot.skip(ftype)
13463 
      iprot.readFieldEnd()
13464 
    iprot.readStructEnd()
13465 
 
13466 
  def write(self, oprot):
13467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13469 
      return
13470 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
13471 
    oprot.writeFieldStop()
13472 
    oprot.writeStructEnd()
13473 
 
13474 
  def validate(self):
13475 
    return
13476 
 
13477 
 
13478 
  def __repr__(self):
13479 
    L = ['%s=%r' % (key, value)
13480 
      for key, value in self.__dict__.iteritems()]
13481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13482 
 
13483 
  def __eq__(self, other):
13484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13485 
 
13486 
  def __ne__(self, other):
13487 
    return not (self == other)
4018 chandransh 13488 
 
13489 
class getItemWiseRiskyOrdersCount_args:
13490 
 
13491 
  thrift_spec = (
13492 
  )
13493 
 
13494 
  def read(self, iprot):
13495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13497 
      return
13498 
    iprot.readStructBegin()
13499 
    while True:
13500 
      (fname, ftype, fid) = iprot.readFieldBegin()
13501 
      if ftype == TType.STOP:
13502 
        break
13503 
      else:
13504 
        iprot.skip(ftype)
13505 
      iprot.readFieldEnd()
13506 
    iprot.readStructEnd()
13507 
 
13508 
  def write(self, oprot):
13509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13511 
      return
13512 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
13513 
    oprot.writeFieldStop()
13514 
    oprot.writeStructEnd()
13515 
 
13516 
  def validate(self):
13517 
    return
13518 
 
13519 
 
13520 
  def __repr__(self):
13521 
    L = ['%s=%r' % (key, value)
13522 
      for key, value in self.__dict__.iteritems()]
13523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13524 
 
13525 
  def __eq__(self, other):
13526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13527 
 
13528 
  def __ne__(self, other):
13529 
    return not (self == other)
13530 
 
13531 
class getItemWiseRiskyOrdersCount_result:
13532 
  """
13533 
  Attributes:
13534 
   - success
13535 
  """
13536 
 
13537 
  thrift_spec = (
13538 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
13539 
  )
13540 
 
13541 
  def __init__(self, success=None,):
13542 
    self.success = success
13543 
 
13544 
  def read(self, iprot):
13545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13547 
      return
13548 
    iprot.readStructBegin()
13549 
    while True:
13550 
      (fname, ftype, fid) = iprot.readFieldBegin()
13551 
      if ftype == TType.STOP:
13552 
        break
13553 
      if fid == 0:
13554 
        if ftype == TType.MAP:
13555 
          self.success = {}
4133 chandransh 13556 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
13557 
          for _i242 in xrange(_size238):
13558 
            _key243 = iprot.readI64();
13559 
            _val244 = iprot.readI64();
13560 
            self.success[_key243] = _val244
4018 chandransh 13561 
          iprot.readMapEnd()
13562 
        else:
13563 
          iprot.skip(ftype)
13564 
      else:
13565 
        iprot.skip(ftype)
13566 
      iprot.readFieldEnd()
13567 
    iprot.readStructEnd()
13568 
 
13569 
  def write(self, oprot):
13570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13572 
      return
13573 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
13574 
    if self.success is not None:
13575 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13576 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 13577 
      for kiter245,viter246 in self.success.items():
13578 
        oprot.writeI64(kiter245)
13579 
        oprot.writeI64(viter246)
4018 chandransh 13580 
      oprot.writeMapEnd()
13581 
      oprot.writeFieldEnd()
13582 
    oprot.writeFieldStop()
13583 
    oprot.writeStructEnd()
13584 
 
13585 
  def validate(self):
13586 
    return
13587 
 
13588 
 
13589 
  def __repr__(self):
13590 
    L = ['%s=%r' % (key, value)
13591 
      for key, value in self.__dict__.iteritems()]
13592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13593 
 
13594 
  def __eq__(self, other):
13595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13596 
 
13597 
  def __ne__(self, other):
13598 
    return not (self == other)
4247 rajveer 13599 
 
4295 varun.gupt 13600 
class getOrdersForItemIds_args:
13601 
  """
13602 
  Attributes:
13603 
   - itemIds
13604 
  """
13605 
 
13606 
  thrift_spec = (
13607 
    None, # 0
13608 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
13609 
  )
13610 
 
13611 
  def __init__(self, itemIds=None,):
13612 
    self.itemIds = itemIds
13613 
 
13614 
  def read(self, iprot):
13615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13617 
      return
13618 
    iprot.readStructBegin()
13619 
    while True:
13620 
      (fname, ftype, fid) = iprot.readFieldBegin()
13621 
      if ftype == TType.STOP:
13622 
        break
13623 
      if fid == 1:
13624 
        if ftype == TType.LIST:
13625 
          self.itemIds = []
13626 
          (_etype250, _size247) = iprot.readListBegin()
13627 
          for _i251 in xrange(_size247):
13628 
            _elem252 = iprot.readI64();
13629 
            self.itemIds.append(_elem252)
13630 
          iprot.readListEnd()
13631 
        else:
13632 
          iprot.skip(ftype)
13633 
      else:
13634 
        iprot.skip(ftype)
13635 
      iprot.readFieldEnd()
13636 
    iprot.readStructEnd()
13637 
 
13638 
  def write(self, oprot):
13639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13641 
      return
13642 
    oprot.writeStructBegin('getOrdersForItemIds_args')
13643 
    if self.itemIds is not None:
13644 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
13645 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13646 
      for iter253 in self.itemIds:
13647 
        oprot.writeI64(iter253)
13648 
      oprot.writeListEnd()
13649 
      oprot.writeFieldEnd()
13650 
    oprot.writeFieldStop()
13651 
    oprot.writeStructEnd()
13652 
 
13653 
  def validate(self):
13654 
    return
13655 
 
13656 
 
13657 
  def __repr__(self):
13658 
    L = ['%s=%r' % (key, value)
13659 
      for key, value in self.__dict__.iteritems()]
13660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13661 
 
13662 
  def __eq__(self, other):
13663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13664 
 
13665 
  def __ne__(self, other):
13666 
    return not (self == other)
13667 
 
13668 
class getOrdersForItemIds_result:
13669 
  """
13670 
  Attributes:
13671 
   - success
13672 
  """
13673 
 
13674 
  thrift_spec = (
13675 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13676 
  )
13677 
 
13678 
  def __init__(self, success=None,):
13679 
    self.success = success
13680 
 
13681 
  def read(self, iprot):
13682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13684 
      return
13685 
    iprot.readStructBegin()
13686 
    while True:
13687 
      (fname, ftype, fid) = iprot.readFieldBegin()
13688 
      if ftype == TType.STOP:
13689 
        break
13690 
      if fid == 0:
13691 
        if ftype == TType.LIST:
13692 
          self.success = []
13693 
          (_etype257, _size254) = iprot.readListBegin()
13694 
          for _i258 in xrange(_size254):
13695 
            _elem259 = Order()
13696 
            _elem259.read(iprot)
13697 
            self.success.append(_elem259)
13698 
          iprot.readListEnd()
13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      else:
13702 
        iprot.skip(ftype)
13703 
      iprot.readFieldEnd()
13704 
    iprot.readStructEnd()
13705 
 
13706 
  def write(self, oprot):
13707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13709 
      return
13710 
    oprot.writeStructBegin('getOrdersForItemIds_result')
13711 
    if self.success is not None:
13712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13713 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13714 
      for iter260 in self.success:
13715 
        iter260.write(oprot)
13716 
      oprot.writeListEnd()
13717 
      oprot.writeFieldEnd()
13718 
    oprot.writeFieldStop()
13719 
    oprot.writeStructEnd()
13720 
 
13721 
  def validate(self):
13722 
    return
13723 
 
13724 
 
13725 
  def __repr__(self):
13726 
    L = ['%s=%r' % (key, value)
13727 
      for key, value in self.__dict__.iteritems()]
13728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13729 
 
13730 
  def __eq__(self, other):
13731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13732 
 
13733 
  def __ne__(self, other):
13734 
    return not (self == other)
13735 
 
4247 rajveer 13736 
class markOrderCancellationRequestReceived_args:
13737 
  """
13738 
  Attributes:
13739 
   - orderId
13740 
  """
13741 
 
13742 
  thrift_spec = (
13743 
    None, # 0
13744 
    (1, TType.I64, 'orderId', None, None, ), # 1
13745 
  )
13746 
 
13747 
  def __init__(self, orderId=None,):
13748 
    self.orderId = orderId
13749 
 
13750 
  def read(self, iprot):
13751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13753 
      return
13754 
    iprot.readStructBegin()
13755 
    while True:
13756 
      (fname, ftype, fid) = iprot.readFieldBegin()
13757 
      if ftype == TType.STOP:
13758 
        break
13759 
      if fid == 1:
13760 
        if ftype == TType.I64:
13761 
          self.orderId = iprot.readI64();
13762 
        else:
13763 
          iprot.skip(ftype)
13764 
      else:
13765 
        iprot.skip(ftype)
13766 
      iprot.readFieldEnd()
13767 
    iprot.readStructEnd()
13768 
 
13769 
  def write(self, oprot):
13770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13772 
      return
13773 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
13774 
    if self.orderId is not None:
13775 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13776 
      oprot.writeI64(self.orderId)
13777 
      oprot.writeFieldEnd()
13778 
    oprot.writeFieldStop()
13779 
    oprot.writeStructEnd()
13780 
 
13781 
  def validate(self):
13782 
    return
13783 
 
13784 
 
13785 
  def __repr__(self):
13786 
    L = ['%s=%r' % (key, value)
13787 
      for key, value in self.__dict__.iteritems()]
13788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13789 
 
13790 
  def __eq__(self, other):
13791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13792 
 
13793 
  def __ne__(self, other):
13794 
    return not (self == other)
13795 
 
13796 
class markOrderCancellationRequestReceived_result:
13797 
  """
13798 
  Attributes:
13799 
   - ex
13800 
  """
13801 
 
13802 
  thrift_spec = (
13803 
    None, # 0
13804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13805 
  )
13806 
 
13807 
  def __init__(self, ex=None,):
13808 
    self.ex = ex
13809 
 
13810 
  def read(self, iprot):
13811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13813 
      return
13814 
    iprot.readStructBegin()
13815 
    while True:
13816 
      (fname, ftype, fid) = iprot.readFieldBegin()
13817 
      if ftype == TType.STOP:
13818 
        break
13819 
      if fid == 1:
13820 
        if ftype == TType.STRUCT:
13821 
          self.ex = TransactionServiceException()
13822 
          self.ex.read(iprot)
13823 
        else:
13824 
          iprot.skip(ftype)
13825 
      else:
13826 
        iprot.skip(ftype)
13827 
      iprot.readFieldEnd()
13828 
    iprot.readStructEnd()
13829 
 
13830 
  def write(self, oprot):
13831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13833 
      return
13834 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
13835 
    if self.ex is not None:
13836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13837 
      self.ex.write(oprot)
13838 
      oprot.writeFieldEnd()
13839 
    oprot.writeFieldStop()
13840 
    oprot.writeStructEnd()
13841 
 
13842 
  def validate(self):
13843 
    return
13844 
 
13845 
 
13846 
  def __repr__(self):
13847 
    L = ['%s=%r' % (key, value)
13848 
      for key, value in self.__dict__.iteritems()]
13849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13850 
 
13851 
  def __eq__(self, other):
13852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13853 
 
13854 
  def __ne__(self, other):
13855 
    return not (self == other)
13856 
 
13857 
class markOrderCancellationRequestConfirmed_args:
13858 
  """
13859 
  Attributes:
13860 
   - orderId
13861 
  """
13862 
 
13863 
  thrift_spec = (
13864 
    None, # 0
13865 
    (1, TType.I64, 'orderId', None, None, ), # 1
13866 
  )
13867 
 
13868 
  def __init__(self, orderId=None,):
13869 
    self.orderId = orderId
13870 
 
13871 
  def read(self, iprot):
13872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13874 
      return
13875 
    iprot.readStructBegin()
13876 
    while True:
13877 
      (fname, ftype, fid) = iprot.readFieldBegin()
13878 
      if ftype == TType.STOP:
13879 
        break
13880 
      if fid == 1:
13881 
        if ftype == TType.I64:
13882 
          self.orderId = iprot.readI64();
13883 
        else:
13884 
          iprot.skip(ftype)
13885 
      else:
13886 
        iprot.skip(ftype)
13887 
      iprot.readFieldEnd()
13888 
    iprot.readStructEnd()
13889 
 
13890 
  def write(self, oprot):
13891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13893 
      return
13894 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13895 
    if self.orderId is not None:
13896 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13897 
      oprot.writeI64(self.orderId)
13898 
      oprot.writeFieldEnd()
13899 
    oprot.writeFieldStop()
13900 
    oprot.writeStructEnd()
13901 
 
13902 
  def validate(self):
13903 
    return
13904 
 
13905 
 
13906 
  def __repr__(self):
13907 
    L = ['%s=%r' % (key, value)
13908 
      for key, value in self.__dict__.iteritems()]
13909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13910 
 
13911 
  def __eq__(self, other):
13912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13913 
 
13914 
  def __ne__(self, other):
13915 
    return not (self == other)
13916 
 
13917 
class markOrderCancellationRequestConfirmed_result:
13918 
  """
13919 
  Attributes:
13920 
   - ex
13921 
  """
13922 
 
13923 
  thrift_spec = (
13924 
    None, # 0
13925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13926 
  )
13927 
 
13928 
  def __init__(self, ex=None,):
13929 
    self.ex = ex
13930 
 
13931 
  def read(self, iprot):
13932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13934 
      return
13935 
    iprot.readStructBegin()
13936 
    while True:
13937 
      (fname, ftype, fid) = iprot.readFieldBegin()
13938 
      if ftype == TType.STOP:
13939 
        break
13940 
      if fid == 1:
13941 
        if ftype == TType.STRUCT:
13942 
          self.ex = TransactionServiceException()
13943 
          self.ex.read(iprot)
13944 
        else:
13945 
          iprot.skip(ftype)
13946 
      else:
13947 
        iprot.skip(ftype)
13948 
      iprot.readFieldEnd()
13949 
    iprot.readStructEnd()
13950 
 
13951 
  def write(self, oprot):
13952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13954 
      return
13955 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13956 
    if self.ex is not None:
13957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13958 
      self.ex.write(oprot)
13959 
      oprot.writeFieldEnd()
13960 
    oprot.writeFieldStop()
13961 
    oprot.writeStructEnd()
13962 
 
13963 
  def validate(self):
13964 
    return
13965 
 
13966 
 
13967 
  def __repr__(self):
13968 
    L = ['%s=%r' % (key, value)
13969 
      for key, value in self.__dict__.iteritems()]
13970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13971 
 
13972 
  def __eq__(self, other):
13973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13974 
 
13975 
  def __ne__(self, other):
13976 
    return not (self == other)
13977 
 
13978 
class markOrderCancellationRequestDenied_args:
13979 
  """
13980 
  Attributes:
13981 
   - orderId
13982 
  """
13983 
 
13984 
  thrift_spec = (
13985 
    None, # 0
13986 
    (1, TType.I64, 'orderId', None, None, ), # 1
13987 
  )
13988 
 
13989 
  def __init__(self, orderId=None,):
13990 
    self.orderId = orderId
13991 
 
13992 
  def read(self, iprot):
13993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13995 
      return
13996 
    iprot.readStructBegin()
13997 
    while True:
13998 
      (fname, ftype, fid) = iprot.readFieldBegin()
13999 
      if ftype == TType.STOP:
14000 
        break
14001 
      if fid == 1:
14002 
        if ftype == TType.I64:
14003 
          self.orderId = iprot.readI64();
14004 
        else:
14005 
          iprot.skip(ftype)
14006 
      else:
14007 
        iprot.skip(ftype)
14008 
      iprot.readFieldEnd()
14009 
    iprot.readStructEnd()
14010 
 
14011 
  def write(self, oprot):
14012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14014 
      return
14015 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14016 
    if self.orderId is not None:
14017 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14018 
      oprot.writeI64(self.orderId)
14019 
      oprot.writeFieldEnd()
14020 
    oprot.writeFieldStop()
14021 
    oprot.writeStructEnd()
14022 
 
14023 
  def validate(self):
14024 
    return
14025 
 
14026 
 
14027 
  def __repr__(self):
14028 
    L = ['%s=%r' % (key, value)
14029 
      for key, value in self.__dict__.iteritems()]
14030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14031 
 
14032 
  def __eq__(self, other):
14033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14034 
 
14035 
  def __ne__(self, other):
14036 
    return not (self == other)
14037 
 
14038 
class markOrderCancellationRequestDenied_result:
14039 
  """
14040 
  Attributes:
14041 
   - ex
14042 
  """
14043 
 
14044 
  thrift_spec = (
14045 
    None, # 0
14046 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14047 
  )
14048 
 
14049 
  def __init__(self, ex=None,):
14050 
    self.ex = ex
14051 
 
14052 
  def read(self, iprot):
14053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14055 
      return
14056 
    iprot.readStructBegin()
14057 
    while True:
14058 
      (fname, ftype, fid) = iprot.readFieldBegin()
14059 
      if ftype == TType.STOP:
14060 
        break
14061 
      if fid == 1:
14062 
        if ftype == TType.STRUCT:
14063 
          self.ex = TransactionServiceException()
14064 
          self.ex.read(iprot)
14065 
        else:
14066 
          iprot.skip(ftype)
14067 
      else:
14068 
        iprot.skip(ftype)
14069 
      iprot.readFieldEnd()
14070 
    iprot.readStructEnd()
14071 
 
14072 
  def write(self, oprot):
14073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14075 
      return
14076 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14077 
    if self.ex is not None:
14078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14079 
      self.ex.write(oprot)
14080 
      oprot.writeFieldEnd()
14081 
    oprot.writeFieldStop()
14082 
    oprot.writeStructEnd()
14083 
 
14084 
  def validate(self):
14085 
    return
14086 
 
14087 
 
14088 
  def __repr__(self):
14089 
    L = ['%s=%r' % (key, value)
14090 
      for key, value in self.__dict__.iteritems()]
14091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14092 
 
14093 
  def __eq__(self, other):
14094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14095 
 
14096 
  def __ne__(self, other):
14097 
    return not (self == other)
14098 
 
4258 rajveer 14099 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14100 
  """
14101 
  Attributes:
4258 rajveer 14102 
   - transactionId
4247 rajveer 14103 
  """
14104 
 
14105 
  thrift_spec = (
14106 
    None, # 0
4258 rajveer 14107 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14108 
  )
14109 
 
4258 rajveer 14110 
  def __init__(self, transactionId=None,):
14111 
    self.transactionId = transactionId
4247 rajveer 14112 
 
14113 
  def read(self, iprot):
14114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14116 
      return
14117 
    iprot.readStructBegin()
14118 
    while True:
14119 
      (fname, ftype, fid) = iprot.readFieldBegin()
14120 
      if ftype == TType.STOP:
14121 
        break
14122 
      if fid == 1:
14123 
        if ftype == TType.I64:
4258 rajveer 14124 
          self.transactionId = iprot.readI64();
4247 rajveer 14125 
        else:
14126 
          iprot.skip(ftype)
14127 
      else:
14128 
        iprot.skip(ftype)
14129 
      iprot.readFieldEnd()
14130 
    iprot.readStructEnd()
14131 
 
14132 
  def write(self, oprot):
14133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14135 
      return
4258 rajveer 14136 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
14137 
    if self.transactionId is not None:
14138 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14139 
      oprot.writeI64(self.transactionId)
4247 rajveer 14140 
      oprot.writeFieldEnd()
14141 
    oprot.writeFieldStop()
14142 
    oprot.writeStructEnd()
14143 
 
14144 
  def validate(self):
14145 
    return
14146 
 
14147 
 
14148 
  def __repr__(self):
14149 
    L = ['%s=%r' % (key, value)
14150 
      for key, value in self.__dict__.iteritems()]
14151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14152 
 
14153 
  def __eq__(self, other):
14154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14155 
 
14156 
  def __ne__(self, other):
14157 
    return not (self == other)
14158 
 
4258 rajveer 14159 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 14160 
  """
14161 
  Attributes:
14162 
   - ex
14163 
  """
14164 
 
14165 
  thrift_spec = (
14166 
    None, # 0
14167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14168 
  )
14169 
 
14170 
  def __init__(self, ex=None,):
14171 
    self.ex = ex
14172 
 
14173 
  def read(self, iprot):
14174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14176 
      return
14177 
    iprot.readStructBegin()
14178 
    while True:
14179 
      (fname, ftype, fid) = iprot.readFieldBegin()
14180 
      if ftype == TType.STOP:
14181 
        break
14182 
      if fid == 1:
14183 
        if ftype == TType.STRUCT:
14184 
          self.ex = TransactionServiceException()
14185 
          self.ex.read(iprot)
14186 
        else:
14187 
          iprot.skip(ftype)
14188 
      else:
14189 
        iprot.skip(ftype)
14190 
      iprot.readFieldEnd()
14191 
    iprot.readStructEnd()
14192 
 
14193 
  def write(self, oprot):
14194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14196 
      return
4258 rajveer 14197 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 14198 
    if self.ex is not None:
14199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14200 
      self.ex.write(oprot)
14201 
      oprot.writeFieldEnd()
14202 
    oprot.writeFieldStop()
14203 
    oprot.writeStructEnd()
14204 
 
14205 
  def validate(self):
14206 
    return
14207 
 
14208 
 
14209 
  def __repr__(self):
14210 
    L = ['%s=%r' % (key, value)
14211 
      for key, value in self.__dict__.iteritems()]
14212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14213 
 
14214 
  def __eq__(self, other):
14215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14216 
 
14217 
  def __ne__(self, other):
14218 
    return not (self == other)
4259 anupam.sin 14219 
 
14220 
class refundTransaction_args:
14221 
  """
14222 
  Attributes:
14223 
   - transactionId
14224 
   - refundedBy
14225 
   - reason
14226 
  """
14227 
 
14228 
  thrift_spec = (
14229 
    None, # 0
14230 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14231 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14232 
    (3, TType.STRING, 'reason', None, None, ), # 3
14233 
  )
14234 
 
14235 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
14236 
    self.transactionId = transactionId
14237 
    self.refundedBy = refundedBy
14238 
    self.reason = reason
14239 
 
14240 
  def read(self, iprot):
14241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14243 
      return
14244 
    iprot.readStructBegin()
14245 
    while True:
14246 
      (fname, ftype, fid) = iprot.readFieldBegin()
14247 
      if ftype == TType.STOP:
14248 
        break
14249 
      if fid == 1:
14250 
        if ftype == TType.I64:
14251 
          self.transactionId = iprot.readI64();
14252 
        else:
14253 
          iprot.skip(ftype)
14254 
      elif fid == 2:
14255 
        if ftype == TType.STRING:
14256 
          self.refundedBy = iprot.readString();
14257 
        else:
14258 
          iprot.skip(ftype)
14259 
      elif fid == 3:
14260 
        if ftype == TType.STRING:
14261 
          self.reason = iprot.readString();
14262 
        else:
14263 
          iprot.skip(ftype)
14264 
      else:
14265 
        iprot.skip(ftype)
14266 
      iprot.readFieldEnd()
14267 
    iprot.readStructEnd()
14268 
 
14269 
  def write(self, oprot):
14270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14272 
      return
14273 
    oprot.writeStructBegin('refundTransaction_args')
14274 
    if self.transactionId is not None:
14275 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14276 
      oprot.writeI64(self.transactionId)
14277 
      oprot.writeFieldEnd()
14278 
    if self.refundedBy is not None:
14279 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14280 
      oprot.writeString(self.refundedBy)
14281 
      oprot.writeFieldEnd()
14282 
    if self.reason is not None:
14283 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14284 
      oprot.writeString(self.reason)
14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
14303 
 
14304 
class refundTransaction_result:
14305 
  """
14306 
  Attributes:
14307 
   - ex
14308 
  """
14309 
 
14310 
  thrift_spec = (
14311 
    None, # 0
14312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14313 
  )
14314 
 
14315 
  def __init__(self, ex=None,):
14316 
    self.ex = ex
14317 
 
14318 
  def read(self, iprot):
14319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14321 
      return
14322 
    iprot.readStructBegin()
14323 
    while True:
14324 
      (fname, ftype, fid) = iprot.readFieldBegin()
14325 
      if ftype == TType.STOP:
14326 
        break
14327 
      if fid == 1:
14328 
        if ftype == TType.STRUCT:
14329 
          self.ex = TransactionServiceException()
14330 
          self.ex.read(iprot)
14331 
        else:
14332 
          iprot.skip(ftype)
14333 
      else:
14334 
        iprot.skip(ftype)
14335 
      iprot.readFieldEnd()
14336 
    iprot.readStructEnd()
14337 
 
14338 
  def write(self, oprot):
14339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14341 
      return
14342 
    oprot.writeStructBegin('refundTransaction_result')
14343 
    if self.ex is not None:
14344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14345 
      self.ex.write(oprot)
14346 
      oprot.writeFieldEnd()
14347 
    oprot.writeFieldStop()
14348 
    oprot.writeStructEnd()
14349 
 
14350 
  def validate(self):
14351 
    return
14352 
 
14353 
 
14354 
  def __repr__(self):
14355 
    L = ['%s=%r' % (key, value)
14356 
      for key, value in self.__dict__.iteritems()]
14357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14358 
 
14359 
  def __eq__(self, other):
14360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14361 
 
14362 
  def __ne__(self, other):
14363 
    return not (self == other)
4285 rajveer 14364 
 
4324 mandeep.dh 14365 
class updateShipmentAddress_args:
14366 
  """
14367 
  Attributes:
14368 
   - orderId
14369 
   - addressId
14370 
  """
14371 
 
14372 
  thrift_spec = (
14373 
    None, # 0
14374 
    (1, TType.I64, 'orderId', None, None, ), # 1
14375 
    (2, TType.I64, 'addressId', None, None, ), # 2
14376 
  )
14377 
 
14378 
  def __init__(self, orderId=None, addressId=None,):
14379 
    self.orderId = orderId
14380 
    self.addressId = addressId
14381 
 
14382 
  def read(self, iprot):
14383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14385 
      return
14386 
    iprot.readStructBegin()
14387 
    while True:
14388 
      (fname, ftype, fid) = iprot.readFieldBegin()
14389 
      if ftype == TType.STOP:
14390 
        break
14391 
      if fid == 1:
14392 
        if ftype == TType.I64:
14393 
          self.orderId = iprot.readI64();
14394 
        else:
14395 
          iprot.skip(ftype)
14396 
      elif fid == 2:
14397 
        if ftype == TType.I64:
14398 
          self.addressId = iprot.readI64();
14399 
        else:
14400 
          iprot.skip(ftype)
14401 
      else:
14402 
        iprot.skip(ftype)
14403 
      iprot.readFieldEnd()
14404 
    iprot.readStructEnd()
14405 
 
14406 
  def write(self, oprot):
14407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14409 
      return
14410 
    oprot.writeStructBegin('updateShipmentAddress_args')
14411 
    if self.orderId is not None:
14412 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14413 
      oprot.writeI64(self.orderId)
14414 
      oprot.writeFieldEnd()
14415 
    if self.addressId is not None:
14416 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
14417 
      oprot.writeI64(self.addressId)
14418 
      oprot.writeFieldEnd()
14419 
    oprot.writeFieldStop()
14420 
    oprot.writeStructEnd()
14421 
 
14422 
  def validate(self):
14423 
    return
14424 
 
14425 
 
14426 
  def __repr__(self):
14427 
    L = ['%s=%r' % (key, value)
14428 
      for key, value in self.__dict__.iteritems()]
14429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14430 
 
14431 
  def __eq__(self, other):
14432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14433 
 
14434 
  def __ne__(self, other):
14435 
    return not (self == other)
14436 
 
14437 
class updateShipmentAddress_result:
14438 
  """
14439 
  Attributes:
14440 
   - ex
14441 
  """
14442 
 
14443 
  thrift_spec = (
14444 
    None, # 0
14445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14446 
  )
14447 
 
14448 
  def __init__(self, ex=None,):
14449 
    self.ex = ex
14450 
 
14451 
  def read(self, iprot):
14452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14454 
      return
14455 
    iprot.readStructBegin()
14456 
    while True:
14457 
      (fname, ftype, fid) = iprot.readFieldBegin()
14458 
      if ftype == TType.STOP:
14459 
        break
14460 
      if fid == 1:
14461 
        if ftype == TType.STRUCT:
14462 
          self.ex = TransactionServiceException()
14463 
          self.ex.read(iprot)
14464 
        else:
14465 
          iprot.skip(ftype)
14466 
      else:
14467 
        iprot.skip(ftype)
14468 
      iprot.readFieldEnd()
14469 
    iprot.readStructEnd()
14470 
 
14471 
  def write(self, oprot):
14472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14474 
      return
14475 
    oprot.writeStructBegin('updateShipmentAddress_result')
14476 
    if self.ex is not None:
14477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14478 
      self.ex.write(oprot)
14479 
      oprot.writeFieldEnd()
14480 
    oprot.writeFieldStop()
14481 
    oprot.writeStructEnd()
14482 
 
14483 
  def validate(self):
14484 
    return
14485 
 
14486 
 
14487 
  def __repr__(self):
14488 
    L = ['%s=%r' % (key, value)
14489 
      for key, value in self.__dict__.iteritems()]
14490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14491 
 
14492 
  def __eq__(self, other):
14493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14494 
 
14495 
  def __ne__(self, other):
14496 
    return not (self == other)
14497 
 
4285 rajveer 14498 
class acceptOrdersForItemId_args:
14499 
  """
14500 
  Attributes:
14501 
   - itemId
14502 
   - inventory
14503 
  """
14504 
 
14505 
  thrift_spec = (
14506 
    None, # 0
14507 
    (1, TType.I64, 'itemId', None, None, ), # 1
14508 
    (2, TType.I64, 'inventory', None, None, ), # 2
14509 
  )
14510 
 
14511 
  def __init__(self, itemId=None, inventory=None,):
14512 
    self.itemId = itemId
14513 
    self.inventory = inventory
14514 
 
14515 
  def read(self, iprot):
14516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14518 
      return
14519 
    iprot.readStructBegin()
14520 
    while True:
14521 
      (fname, ftype, fid) = iprot.readFieldBegin()
14522 
      if ftype == TType.STOP:
14523 
        break
14524 
      if fid == 1:
14525 
        if ftype == TType.I64:
14526 
          self.itemId = iprot.readI64();
14527 
        else:
14528 
          iprot.skip(ftype)
14529 
      elif fid == 2:
14530 
        if ftype == TType.I64:
14531 
          self.inventory = iprot.readI64();
14532 
        else:
14533 
          iprot.skip(ftype)
14534 
      else:
14535 
        iprot.skip(ftype)
14536 
      iprot.readFieldEnd()
14537 
    iprot.readStructEnd()
14538 
 
14539 
  def write(self, oprot):
14540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14542 
      return
14543 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
14544 
    if self.itemId is not None:
14545 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14546 
      oprot.writeI64(self.itemId)
14547 
      oprot.writeFieldEnd()
14548 
    if self.inventory is not None:
14549 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
14550 
      oprot.writeI64(self.inventory)
14551 
      oprot.writeFieldEnd()
14552 
    oprot.writeFieldStop()
14553 
    oprot.writeStructEnd()
14554 
 
14555 
  def validate(self):
14556 
    return
14557 
 
14558 
 
14559 
  def __repr__(self):
14560 
    L = ['%s=%r' % (key, value)
14561 
      for key, value in self.__dict__.iteritems()]
14562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14563 
 
14564 
  def __eq__(self, other):
14565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14566 
 
14567 
  def __ne__(self, other):
14568 
    return not (self == other)
14569 
 
14570 
class acceptOrdersForItemId_result:
14571 
  """
14572 
  Attributes:
14573 
   - success
14574 
   - ex
14575 
  """
14576 
 
14577 
  thrift_spec = (
14578 
    (0, TType.BOOL, 'success', None, None, ), # 0
14579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14580 
  )
14581 
 
14582 
  def __init__(self, success=None, ex=None,):
14583 
    self.success = success
14584 
    self.ex = ex
14585 
 
14586 
  def read(self, iprot):
14587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14589 
      return
14590 
    iprot.readStructBegin()
14591 
    while True:
14592 
      (fname, ftype, fid) = iprot.readFieldBegin()
14593 
      if ftype == TType.STOP:
14594 
        break
14595 
      if fid == 0:
14596 
        if ftype == TType.BOOL:
14597 
          self.success = iprot.readBool();
14598 
        else:
14599 
          iprot.skip(ftype)
14600 
      elif fid == 1:
14601 
        if ftype == TType.STRUCT:
14602 
          self.ex = TransactionServiceException()
14603 
          self.ex.read(iprot)
14604 
        else:
14605 
          iprot.skip(ftype)
14606 
      else:
14607 
        iprot.skip(ftype)
14608 
      iprot.readFieldEnd()
14609 
    iprot.readStructEnd()
14610 
 
14611 
  def write(self, oprot):
14612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14614 
      return
14615 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
14616 
    if self.success is not None:
14617 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14618 
      oprot.writeBool(self.success)
14619 
      oprot.writeFieldEnd()
14620 
    if self.ex is not None:
14621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14622 
      self.ex.write(oprot)
14623 
      oprot.writeFieldEnd()
14624 
    oprot.writeFieldStop()
14625 
    oprot.writeStructEnd()
14626 
 
14627 
  def validate(self):
14628 
    return
14629 
 
14630 
 
14631 
  def __repr__(self):
14632 
    L = ['%s=%r' % (key, value)
14633 
      for key, value in self.__dict__.iteritems()]
14634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14635 
 
14636 
  def __eq__(self, other):
14637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14638 
 
14639 
  def __ne__(self, other):
14640 
    return not (self == other)
4303 rajveer 14641 
 
14642 
class markOrdersAsPORaised_args:
14643 
  """
14644 
  Attributes:
14645 
   - vendorId
14646 
   - itemId
14647 
   - quantity
14648 
   - estimate
4369 rajveer 14649 
   - isReminder
4303 rajveer 14650 
  """
14651 
 
14652 
  thrift_spec = (
14653 
    None, # 0
14654 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14655 
    (2, TType.I64, 'itemId', None, None, ), # 2
14656 
    (3, TType.I64, 'quantity', None, None, ), # 3
14657 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14658 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14659 
  )
14660 
 
4369 rajveer 14661 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14662 
    self.vendorId = vendorId
14663 
    self.itemId = itemId
14664 
    self.quantity = quantity
14665 
    self.estimate = estimate
4369 rajveer 14666 
    self.isReminder = isReminder
4303 rajveer 14667 
 
14668 
  def read(self, iprot):
14669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14671 
      return
14672 
    iprot.readStructBegin()
14673 
    while True:
14674 
      (fname, ftype, fid) = iprot.readFieldBegin()
14675 
      if ftype == TType.STOP:
14676 
        break
14677 
      if fid == 1:
14678 
        if ftype == TType.I64:
14679 
          self.vendorId = iprot.readI64();
14680 
        else:
14681 
          iprot.skip(ftype)
14682 
      elif fid == 2:
14683 
        if ftype == TType.I64:
14684 
          self.itemId = iprot.readI64();
14685 
        else:
14686 
          iprot.skip(ftype)
14687 
      elif fid == 3:
14688 
        if ftype == TType.I64:
14689 
          self.quantity = iprot.readI64();
14690 
        else:
14691 
          iprot.skip(ftype)
14692 
      elif fid == 4:
14693 
        if ftype == TType.I64:
14694 
          self.estimate = iprot.readI64();
14695 
        else:
14696 
          iprot.skip(ftype)
4369 rajveer 14697 
      elif fid == 5:
14698 
        if ftype == TType.BOOL:
14699 
          self.isReminder = iprot.readBool();
14700 
        else:
14701 
          iprot.skip(ftype)
4303 rajveer 14702 
      else:
14703 
        iprot.skip(ftype)
14704 
      iprot.readFieldEnd()
14705 
    iprot.readStructEnd()
14706 
 
14707 
  def write(self, oprot):
14708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14710 
      return
14711 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
14712 
    if self.vendorId is not None:
14713 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14714 
      oprot.writeI64(self.vendorId)
14715 
      oprot.writeFieldEnd()
14716 
    if self.itemId is not None:
14717 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14718 
      oprot.writeI64(self.itemId)
14719 
      oprot.writeFieldEnd()
14720 
    if self.quantity is not None:
14721 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14722 
      oprot.writeI64(self.quantity)
14723 
      oprot.writeFieldEnd()
14724 
    if self.estimate is not None:
14725 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14726 
      oprot.writeI64(self.estimate)
14727 
      oprot.writeFieldEnd()
4369 rajveer 14728 
    if self.isReminder is not None:
14729 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14730 
      oprot.writeBool(self.isReminder)
14731 
      oprot.writeFieldEnd()
4303 rajveer 14732 
    oprot.writeFieldStop()
14733 
    oprot.writeStructEnd()
14734 
 
14735 
  def validate(self):
14736 
    return
14737 
 
14738 
 
14739 
  def __repr__(self):
14740 
    L = ['%s=%r' % (key, value)
14741 
      for key, value in self.__dict__.iteritems()]
14742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14743 
 
14744 
  def __eq__(self, other):
14745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14746 
 
14747 
  def __ne__(self, other):
14748 
    return not (self == other)
14749 
 
14750 
class markOrdersAsPORaised_result:
14751 
  """
14752 
  Attributes:
14753 
   - ex
14754 
  """
14755 
 
14756 
  thrift_spec = (
14757 
    None, # 0
14758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14759 
  )
14760 
 
14761 
  def __init__(self, ex=None,):
14762 
    self.ex = ex
14763 
 
14764 
  def read(self, iprot):
14765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14767 
      return
14768 
    iprot.readStructBegin()
14769 
    while True:
14770 
      (fname, ftype, fid) = iprot.readFieldBegin()
14771 
      if ftype == TType.STOP:
14772 
        break
14773 
      if fid == 1:
14774 
        if ftype == TType.STRUCT:
14775 
          self.ex = TransactionServiceException()
14776 
          self.ex.read(iprot)
14777 
        else:
14778 
          iprot.skip(ftype)
14779 
      else:
14780 
        iprot.skip(ftype)
14781 
      iprot.readFieldEnd()
14782 
    iprot.readStructEnd()
14783 
 
14784 
  def write(self, oprot):
14785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14787 
      return
14788 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
14789 
    if self.ex is not None:
14790 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14791 
      self.ex.write(oprot)
14792 
      oprot.writeFieldEnd()
14793 
    oprot.writeFieldStop()
14794 
    oprot.writeStructEnd()
14795 
 
14796 
  def validate(self):
14797 
    return
14798 
 
14799 
 
14800 
  def __repr__(self):
14801 
    L = ['%s=%r' % (key, value)
14802 
      for key, value in self.__dict__.iteritems()]
14803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14804 
 
14805 
  def __eq__(self, other):
14806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14807 
 
14808 
  def __ne__(self, other):
14809 
    return not (self == other)
14810 
 
14811 
class markOrdersAsReversalInitiated_args:
14812 
  """
14813 
  Attributes:
14814 
   - vendorId
14815 
   - itemId
14816 
   - quantity
14817 
   - estimate
4369 rajveer 14818 
   - isReminder
4303 rajveer 14819 
  """
14820 
 
14821 
  thrift_spec = (
14822 
    None, # 0
14823 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14824 
    (2, TType.I64, 'itemId', None, None, ), # 2
14825 
    (3, TType.I64, 'quantity', None, None, ), # 3
14826 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14827 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14828 
  )
14829 
 
4369 rajveer 14830 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14831 
    self.vendorId = vendorId
14832 
    self.itemId = itemId
14833 
    self.quantity = quantity
14834 
    self.estimate = estimate
4369 rajveer 14835 
    self.isReminder = isReminder
4303 rajveer 14836 
 
14837 
  def read(self, iprot):
14838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14840 
      return
14841 
    iprot.readStructBegin()
14842 
    while True:
14843 
      (fname, ftype, fid) = iprot.readFieldBegin()
14844 
      if ftype == TType.STOP:
14845 
        break
14846 
      if fid == 1:
14847 
        if ftype == TType.I64:
14848 
          self.vendorId = iprot.readI64();
14849 
        else:
14850 
          iprot.skip(ftype)
14851 
      elif fid == 2:
14852 
        if ftype == TType.I64:
14853 
          self.itemId = iprot.readI64();
14854 
        else:
14855 
          iprot.skip(ftype)
14856 
      elif fid == 3:
14857 
        if ftype == TType.I64:
14858 
          self.quantity = iprot.readI64();
14859 
        else:
14860 
          iprot.skip(ftype)
14861 
      elif fid == 4:
14862 
        if ftype == TType.I64:
14863 
          self.estimate = iprot.readI64();
14864 
        else:
14865 
          iprot.skip(ftype)
4369 rajveer 14866 
      elif fid == 5:
14867 
        if ftype == TType.BOOL:
14868 
          self.isReminder = iprot.readBool();
14869 
        else:
14870 
          iprot.skip(ftype)
4303 rajveer 14871 
      else:
14872 
        iprot.skip(ftype)
14873 
      iprot.readFieldEnd()
14874 
    iprot.readStructEnd()
14875 
 
14876 
  def write(self, oprot):
14877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14879 
      return
14880 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14881 
    if self.vendorId is not None:
14882 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14883 
      oprot.writeI64(self.vendorId)
14884 
      oprot.writeFieldEnd()
14885 
    if self.itemId is not None:
14886 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14887 
      oprot.writeI64(self.itemId)
14888 
      oprot.writeFieldEnd()
14889 
    if self.quantity is not None:
14890 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14891 
      oprot.writeI64(self.quantity)
14892 
      oprot.writeFieldEnd()
14893 
    if self.estimate is not None:
14894 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14895 
      oprot.writeI64(self.estimate)
14896 
      oprot.writeFieldEnd()
4369 rajveer 14897 
    if self.isReminder is not None:
14898 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14899 
      oprot.writeBool(self.isReminder)
14900 
      oprot.writeFieldEnd()
4303 rajveer 14901 
    oprot.writeFieldStop()
14902 
    oprot.writeStructEnd()
14903 
 
14904 
  def validate(self):
14905 
    return
14906 
 
14907 
 
14908 
  def __repr__(self):
14909 
    L = ['%s=%r' % (key, value)
14910 
      for key, value in self.__dict__.iteritems()]
14911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14912 
 
14913 
  def __eq__(self, other):
14914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14915 
 
14916 
  def __ne__(self, other):
14917 
    return not (self == other)
14918 
 
14919 
class markOrdersAsReversalInitiated_result:
14920 
  """
14921 
  Attributes:
14922 
   - ex
14923 
  """
14924 
 
14925 
  thrift_spec = (
14926 
    None, # 0
14927 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14928 
  )
14929 
 
14930 
  def __init__(self, ex=None,):
14931 
    self.ex = ex
14932 
 
14933 
  def read(self, iprot):
14934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14936 
      return
14937 
    iprot.readStructBegin()
14938 
    while True:
14939 
      (fname, ftype, fid) = iprot.readFieldBegin()
14940 
      if ftype == TType.STOP:
14941 
        break
14942 
      if fid == 1:
14943 
        if ftype == TType.STRUCT:
14944 
          self.ex = TransactionServiceException()
14945 
          self.ex.read(iprot)
14946 
        else:
14947 
          iprot.skip(ftype)
14948 
      else:
14949 
        iprot.skip(ftype)
14950 
      iprot.readFieldEnd()
14951 
    iprot.readStructEnd()
14952 
 
14953 
  def write(self, oprot):
14954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14956 
      return
14957 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14958 
    if self.ex is not None:
14959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14960 
      self.ex.write(oprot)
14961 
      oprot.writeFieldEnd()
14962 
    oprot.writeFieldStop()
14963 
    oprot.writeStructEnd()
14964 
 
14965 
  def validate(self):
14966 
    return
14967 
 
14968 
 
14969 
  def __repr__(self):
14970 
    L = ['%s=%r' % (key, value)
14971 
      for key, value in self.__dict__.iteritems()]
14972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14973 
 
14974 
  def __eq__(self, other):
14975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14976 
 
14977 
  def __ne__(self, other):
14978 
    return not (self == other)
14979 
 
14980 
class markOrdersAsNotAvailabke_args:
14981 
  """
14982 
  Attributes:
14983 
   - vendorId
14984 
   - itemId
14985 
   - quantity
14986 
   - estimate
4369 rajveer 14987 
   - isReminder
4303 rajveer 14988 
  """
14989 
 
14990 
  thrift_spec = (
14991 
    None, # 0
14992 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14993 
    (2, TType.I64, 'itemId', None, None, ), # 2
14994 
    (3, TType.I64, 'quantity', None, None, ), # 3
14995 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14996 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14997 
  )
14998 
 
4369 rajveer 14999 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15000 
    self.vendorId = vendorId
15001 
    self.itemId = itemId
15002 
    self.quantity = quantity
15003 
    self.estimate = estimate
4369 rajveer 15004 
    self.isReminder = isReminder
4303 rajveer 15005 
 
15006 
  def read(self, iprot):
15007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15009 
      return
15010 
    iprot.readStructBegin()
15011 
    while True:
15012 
      (fname, ftype, fid) = iprot.readFieldBegin()
15013 
      if ftype == TType.STOP:
15014 
        break
15015 
      if fid == 1:
15016 
        if ftype == TType.I64:
15017 
          self.vendorId = iprot.readI64();
15018 
        else:
15019 
          iprot.skip(ftype)
15020 
      elif fid == 2:
15021 
        if ftype == TType.I64:
15022 
          self.itemId = iprot.readI64();
15023 
        else:
15024 
          iprot.skip(ftype)
15025 
      elif fid == 3:
15026 
        if ftype == TType.I64:
15027 
          self.quantity = iprot.readI64();
15028 
        else:
15029 
          iprot.skip(ftype)
15030 
      elif fid == 4:
15031 
        if ftype == TType.I64:
15032 
          self.estimate = iprot.readI64();
15033 
        else:
15034 
          iprot.skip(ftype)
4369 rajveer 15035 
      elif fid == 5:
15036 
        if ftype == TType.BOOL:
15037 
          self.isReminder = iprot.readBool();
15038 
        else:
15039 
          iprot.skip(ftype)
4303 rajveer 15040 
      else:
15041 
        iprot.skip(ftype)
15042 
      iprot.readFieldEnd()
15043 
    iprot.readStructEnd()
15044 
 
15045 
  def write(self, oprot):
15046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15048 
      return
15049 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15050 
    if self.vendorId is not None:
15051 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15052 
      oprot.writeI64(self.vendorId)
15053 
      oprot.writeFieldEnd()
15054 
    if self.itemId is not None:
15055 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15056 
      oprot.writeI64(self.itemId)
15057 
      oprot.writeFieldEnd()
15058 
    if self.quantity is not None:
15059 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15060 
      oprot.writeI64(self.quantity)
15061 
      oprot.writeFieldEnd()
15062 
    if self.estimate is not None:
15063 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15064 
      oprot.writeI64(self.estimate)
15065 
      oprot.writeFieldEnd()
4369 rajveer 15066 
    if self.isReminder is not None:
15067 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15068 
      oprot.writeBool(self.isReminder)
15069 
      oprot.writeFieldEnd()
4303 rajveer 15070 
    oprot.writeFieldStop()
15071 
    oprot.writeStructEnd()
15072 
 
15073 
  def validate(self):
15074 
    return
15075 
 
15076 
 
15077 
  def __repr__(self):
15078 
    L = ['%s=%r' % (key, value)
15079 
      for key, value in self.__dict__.iteritems()]
15080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15081 
 
15082 
  def __eq__(self, other):
15083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15084 
 
15085 
  def __ne__(self, other):
15086 
    return not (self == other)
15087 
 
15088 
class markOrdersAsNotAvailabke_result:
15089 
  """
15090 
  Attributes:
15091 
   - ex
15092 
  """
15093 
 
15094 
  thrift_spec = (
15095 
    None, # 0
15096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15097 
  )
15098 
 
15099 
  def __init__(self, ex=None,):
15100 
    self.ex = ex
15101 
 
15102 
  def read(self, iprot):
15103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15105 
      return
15106 
    iprot.readStructBegin()
15107 
    while True:
15108 
      (fname, ftype, fid) = iprot.readFieldBegin()
15109 
      if ftype == TType.STOP:
15110 
        break
15111 
      if fid == 1:
15112 
        if ftype == TType.STRUCT:
15113 
          self.ex = TransactionServiceException()
15114 
          self.ex.read(iprot)
15115 
        else:
15116 
          iprot.skip(ftype)
15117 
      else:
15118 
        iprot.skip(ftype)
15119 
      iprot.readFieldEnd()
15120 
    iprot.readStructEnd()
15121 
 
15122 
  def write(self, oprot):
15123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15125 
      return
15126 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
15127 
    if self.ex is not None:
15128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15129 
      self.ex.write(oprot)
15130 
      oprot.writeFieldEnd()
15131 
    oprot.writeFieldStop()
15132 
    oprot.writeStructEnd()
15133 
 
15134 
  def validate(self):
15135 
    return
15136 
 
15137 
 
15138 
  def __repr__(self):
15139 
    L = ['%s=%r' % (key, value)
15140 
      for key, value in self.__dict__.iteritems()]
15141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15142 
 
15143 
  def __eq__(self, other):
15144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15145 
 
15146 
  def __ne__(self, other):
15147 
    return not (self == other)
4369 rajveer 15148 
 
15149 
class markOrdersAsTimeout_args:
15150 
  """
15151 
  Attributes:
15152 
   - vendorId
15153 
  """
15154 
 
15155 
  thrift_spec = (
15156 
    None, # 0
15157 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15158 
  )
15159 
 
15160 
  def __init__(self, vendorId=None,):
15161 
    self.vendorId = vendorId
15162 
 
15163 
  def read(self, iprot):
15164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15166 
      return
15167 
    iprot.readStructBegin()
15168 
    while True:
15169 
      (fname, ftype, fid) = iprot.readFieldBegin()
15170 
      if ftype == TType.STOP:
15171 
        break
15172 
      if fid == 1:
15173 
        if ftype == TType.I64:
15174 
          self.vendorId = iprot.readI64();
15175 
        else:
15176 
          iprot.skip(ftype)
15177 
      else:
15178 
        iprot.skip(ftype)
15179 
      iprot.readFieldEnd()
15180 
    iprot.readStructEnd()
15181 
 
15182 
  def write(self, oprot):
15183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15185 
      return
15186 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
15187 
    if self.vendorId is not None:
15188 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15189 
      oprot.writeI64(self.vendorId)
15190 
      oprot.writeFieldEnd()
15191 
    oprot.writeFieldStop()
15192 
    oprot.writeStructEnd()
15193 
 
15194 
  def validate(self):
15195 
    return
15196 
 
15197 
 
15198 
  def __repr__(self):
15199 
    L = ['%s=%r' % (key, value)
15200 
      for key, value in self.__dict__.iteritems()]
15201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15202 
 
15203 
  def __eq__(self, other):
15204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15205 
 
15206 
  def __ne__(self, other):
15207 
    return not (self == other)
15208 
 
15209 
class markOrdersAsTimeout_result:
15210 
  """
15211 
  Attributes:
15212 
   - success
15213 
   - ex
15214 
  """
15215 
 
15216 
  thrift_spec = (
15217 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
15218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15219 
  )
15220 
 
15221 
  def __init__(self, success=None, ex=None,):
15222 
    self.success = success
15223 
    self.ex = ex
15224 
 
15225 
  def read(self, iprot):
15226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15228 
      return
15229 
    iprot.readStructBegin()
15230 
    while True:
15231 
      (fname, ftype, fid) = iprot.readFieldBegin()
15232 
      if ftype == TType.STOP:
15233 
        break
15234 
      if fid == 0:
15235 
        if ftype == TType.MAP:
15236 
          self.success = {}
15237 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15238 
          for _i265 in xrange(_size261):
15239 
            _key266 = iprot.readI32();
15240 
            _val267 = TimeoutSummary()
15241 
            _val267.read(iprot)
15242 
            self.success[_key266] = _val267
15243 
          iprot.readMapEnd()
15244 
        else:
15245 
          iprot.skip(ftype)
15246 
      elif fid == 1:
15247 
        if ftype == TType.STRUCT:
15248 
          self.ex = TransactionServiceException()
15249 
          self.ex.read(iprot)
15250 
        else:
15251 
          iprot.skip(ftype)
15252 
      else:
15253 
        iprot.skip(ftype)
15254 
      iprot.readFieldEnd()
15255 
    iprot.readStructEnd()
15256 
 
15257 
  def write(self, oprot):
15258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15260 
      return
15261 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
15262 
    if self.success is not None:
15263 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15264 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
15265 
      for kiter268,viter269 in self.success.items():
15266 
        oprot.writeI32(kiter268)
15267 
        viter269.write(oprot)
15268 
      oprot.writeMapEnd()
15269 
      oprot.writeFieldEnd()
15270 
    if self.ex is not None:
15271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15272 
      self.ex.write(oprot)
15273 
      oprot.writeFieldEnd()
15274 
    oprot.writeFieldStop()
15275 
    oprot.writeStructEnd()
15276 
 
15277 
  def validate(self):
15278 
    return
15279 
 
15280 
 
15281 
  def __repr__(self):
15282 
    L = ['%s=%r' % (key, value)
15283 
      for key, value in self.__dict__.iteritems()]
15284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15285 
 
15286 
  def __eq__(self, other):
15287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15288 
 
15289 
  def __ne__(self, other):
15290 
    return not (self == other)
4386 anupam.sin 15291 
 
15292 
class getOrderForAwb_args:
15293 
  """
15294 
  Attributes:
15295 
   - awb
15296 
  """
15297 
 
15298 
  thrift_spec = (
15299 
    None, # 0
15300 
    (1, TType.STRING, 'awb', None, None, ), # 1
15301 
  )
15302 
 
15303 
  def __init__(self, awb=None,):
15304 
    self.awb = awb
15305 
 
15306 
  def read(self, iprot):
15307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15309 
      return
15310 
    iprot.readStructBegin()
15311 
    while True:
15312 
      (fname, ftype, fid) = iprot.readFieldBegin()
15313 
      if ftype == TType.STOP:
15314 
        break
15315 
      if fid == 1:
15316 
        if ftype == TType.STRING:
15317 
          self.awb = iprot.readString();
15318 
        else:
15319 
          iprot.skip(ftype)
15320 
      else:
15321 
        iprot.skip(ftype)
15322 
      iprot.readFieldEnd()
15323 
    iprot.readStructEnd()
15324 
 
15325 
  def write(self, oprot):
15326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15328 
      return
15329 
    oprot.writeStructBegin('getOrderForAwb_args')
15330 
    if self.awb is not None:
15331 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
15332 
      oprot.writeString(self.awb)
15333 
      oprot.writeFieldEnd()
15334 
    oprot.writeFieldStop()
15335 
    oprot.writeStructEnd()
15336 
 
15337 
  def validate(self):
15338 
    return
15339 
 
15340 
 
15341 
  def __repr__(self):
15342 
    L = ['%s=%r' % (key, value)
15343 
      for key, value in self.__dict__.iteritems()]
15344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15345 
 
15346 
  def __eq__(self, other):
15347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15348 
 
15349 
  def __ne__(self, other):
15350 
    return not (self == other)
15351 
 
15352 
class getOrderForAwb_result:
15353 
  """
15354 
  Attributes:
15355 
   - success
15356 
   - ex
15357 
  """
15358 
 
15359 
  thrift_spec = (
15360 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
15361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15362 
  )
15363 
 
15364 
  def __init__(self, success=None, ex=None,):
15365 
    self.success = success
15366 
    self.ex = ex
15367 
 
15368 
  def read(self, iprot):
15369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15371 
      return
15372 
    iprot.readStructBegin()
15373 
    while True:
15374 
      (fname, ftype, fid) = iprot.readFieldBegin()
15375 
      if ftype == TType.STOP:
15376 
        break
15377 
      if fid == 0:
15378 
        if ftype == TType.STRUCT:
15379 
          self.success = Order()
15380 
          self.success.read(iprot)
15381 
        else:
15382 
          iprot.skip(ftype)
15383 
      elif fid == 1:
15384 
        if ftype == TType.STRUCT:
15385 
          self.ex = TransactionServiceException()
15386 
          self.ex.read(iprot)
15387 
        else:
15388 
          iprot.skip(ftype)
15389 
      else:
15390 
        iprot.skip(ftype)
15391 
      iprot.readFieldEnd()
15392 
    iprot.readStructEnd()
15393 
 
15394 
  def write(self, oprot):
15395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15397 
      return
15398 
    oprot.writeStructBegin('getOrderForAwb_result')
15399 
    if self.success is not None:
15400 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15401 
      self.success.write(oprot)
15402 
      oprot.writeFieldEnd()
15403 
    if self.ex is not None:
15404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15405 
      self.ex.write(oprot)
15406 
      oprot.writeFieldEnd()
15407 
    oprot.writeFieldStop()
15408 
    oprot.writeStructEnd()
15409 
 
15410 
  def validate(self):
15411 
    return
15412 
 
15413 
 
15414 
  def __repr__(self):
15415 
    L = ['%s=%r' % (key, value)
15416 
      for key, value in self.__dict__.iteritems()]
15417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15418 
 
15419 
  def __eq__(self, other):
15420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15421 
 
15422 
  def __ne__(self, other):
15423 
    return not (self == other)