Subversion Repositories SmartDukaan

Rev

Rev 4506 | Rev 4581 | 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 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 411 
 
1246 chandransh 412 
    Parameters:
413 
     - providerId
414 
     - undeliveredOrders
415 
    """
416 
    pass
417 
 
1408 ankur.sing 418 
  def getUndeliveredOrders(self, providerId, warehouseId):
419 
    """
420 
    Returns the list of orders whose delivery time has passed but have not been
421 
    delivered yet for the given provider and warehouse. To get a complete list of
422 
    undelivered orders, pass them as -1.
423 
    Returns an empty list if no such orders exist.
3431 rajveer 424 
 
1408 ankur.sing 425 
    Parameters:
426 
     - providerId
427 
     - warehouseId
428 
    """
429 
    pass
430 
 
2536 chandransh 431 
  def toggleDOAFlag(self, orderId):
432 
    """
433 
    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.
434 
    Returns the final flag status.
435 
    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 436 
 
2536 chandransh 437 
    Parameters:
438 
     - orderId
439 
    """
440 
    pass
1886 ankur.sing 441 
 
4454 rajveer 442 
  def markOrderDoaRequestReceived(self, orderId):
443 
    """
444 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
445 
 
446 
    Parameters:
447 
     - orderId
448 
    """
449 
    pass
450 
 
451 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
452 
    """
453 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
454 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
455 
 
456 
    Parameters:
457 
     - orderId
458 
     - isAuthorized
459 
    """
460 
    pass
461 
 
4488 rajveer 462 
  def markOrderReturnRequestReceived(self, orderId):
463 
    """
464 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
465 
 
466 
    Parameters:
467 
     - orderId
468 
    """
469 
    pass
470 
 
471 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
472 
    """
473 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
474 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
475 
 
476 
    Parameters:
477 
     - orderId
478 
     - isAuthorized
479 
    """
480 
    pass
481 
 
4579 rajveer 482 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 483 
    """
484 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 485 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
486 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 487 
    For any other status, it returns false.
488 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 489 
 
2536 chandransh 490 
    Parameters:
491 
     - orderId
4579 rajveer 492 
     - providerId
2536 chandransh 493 
    """
494 
    pass
495 
 
496 
  def authorizePickup(self, orderId, pickupNumber):
497 
    """
4452 rajveer 498 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 499 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
500 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
501 
    	3. Returns true
2591 chandransh 502 
    If the order is in any other status, it returns false.
2536 chandransh 503 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 504 
 
2536 chandransh 505 
    Parameters:
506 
     - orderId
507 
     - pickupNumber
508 
    """
509 
    pass
510 
 
2764 chandransh 511 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
512 
    """
513 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
514 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 515 
 
2764 chandransh 516 
    Parameters:
517 
     - providerId
518 
     - pickupDetails
519 
    """
520 
    pass
521 
 
4479 rajveer 522 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 523 
    """
4452 rajveer 524 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 525 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 526 
    If the order is in any other state, it returns false.
527 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 528 
 
2591 chandransh 529 
    Parameters:
530 
     - orderId
4479 rajveer 531 
     - receiveCondition
2591 chandransh 532 
    """
533 
    pass
2536 chandransh 534 
 
2591 chandransh 535 
  def validateDoa(self, orderId, isValid):
536 
    """
4452 rajveer 537 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 538 
    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 539 
    If the order is in any other state, it returns false.
540 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 541 
 
2591 chandransh 542 
    Parameters:
543 
     - orderId
544 
     - isValid
545 
    """
546 
    pass
547 
 
4495 rajveer 548 
  def validateReturnProduct(self, orderId, isUsable):
549 
    """
550 
    Parameters:
551 
     - orderId
552 
     - isUsable
553 
    """
554 
    pass
555 
 
2616 chandransh 556 
  def reshipOrder(self, orderId):
557 
    """
4484 rajveer 558 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 559 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 560 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 561 
 
562 
    If the order is in DOA_CERT_VALID state, it does the following:
563 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
564 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 565 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 566 
 
2616 chandransh 567 
    Returns the id of the newly created order.
3431 rajveer 568 
 
2616 chandransh 569 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 570 
 
2616 chandransh 571 
    Parameters:
572 
     - orderId
573 
    """
574 
    pass
2591 chandransh 575 
 
3226 chandransh 576 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 577 
    """
4484 rajveer 578 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 579 
    	1. Creates a refund request for batch processing.
580 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 581 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 582 
 
2616 chandransh 583 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
584 
    	1. Creates a refund request for batch processing.
3226 chandransh 585 
    	2. Cancels the reservation of the item in the warehouse.
586 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 587 
 
3226 chandransh 588 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
589 
    	1. Cancels the reservation of the item in the warehouse.
590 
    	2. Marks the current order as CANCELED.
591 
 
592 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
593 
 
2616 chandransh 594 
    Returns True if it is successful, False otherwise.
3431 rajveer 595 
 
2616 chandransh 596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2616 chandransh 598 
    Parameters:
599 
     - orderId
3226 chandransh 600 
     - refundedBy
601 
     - reason
2616 chandransh 602 
    """
603 
    pass
604 
 
2690 chandransh 605 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
606 
    """
607 
    Get all return orders created between the from and to dates for the given warehouse.
608 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 609 
 
2690 chandransh 610 
    Parameters:
611 
     - warehouseId
612 
     - fromDate
613 
     - toDate
614 
    """
615 
    pass
2616 chandransh 616 
 
2700 chandransh 617 
  def getReturnOrder(self, id):
618 
    """
619 
    Returns the ReturnOrder corresponding to the given id.
620 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 621 
 
2700 chandransh 622 
    Parameters:
623 
     - id
624 
    """
625 
    pass
626 
 
2690 chandransh 627 
  def processReturn(self, returnOrderId):
628 
    """
629 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 630 
 
2690 chandransh 631 
    Parameters:
632 
     - returnOrderId
633 
    """
634 
    pass
635 
 
2819 chandransh 636 
  def createPurchaseOrder(self, warehouseId):
637 
    """
638 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 639 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 640 
 
2819 chandransh 641 
    Parameters:
642 
     - warehouseId
643 
    """
644 
    pass
2690 chandransh 645 
 
3451 chandransh 646 
  def updateWeight(self, orderId, weight):
647 
    """
648 
    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 649 
 
3451 chandransh 650 
    Parameters:
651 
     - orderId
652 
     - weight
653 
    """
654 
    pass
655 
 
3469 chandransh 656 
  def changeItem(self, orderId, itemId):
657 
    """
658 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
659 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 660 
 
3469 chandransh 661 
    Parameters:
662 
     - orderId
663 
     - itemId
664 
    """
665 
    pass
666 
 
667 
  def shiftToWarehouse(self, orderId, warehouseId):
668 
    """
669 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
670 
 
671 
    Parameters:
672 
     - orderId
673 
     - warehouseId
674 
    """
675 
    pass
676 
 
3986 chandransh 677 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 678 
    """
679 
    Adds the given delay reason to the given order.
3986 chandransh 680 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 681 
    Raises an exception if no order with the given id can be found.
3469 chandransh 682 
 
3553 chandransh 683 
    Parameters:
684 
     - orderId
685 
     - delayReason
3986 chandransh 686 
     - furtherDelay
3553 chandransh 687 
    """
688 
    pass
689 
 
3956 chandransh 690 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
691 
    """
692 
    Marks the COD orders with given AWB nos. as having been processed.
693 
    Updates the captured amount for the corresponding payment.
3553 chandransh 694 
 
3956 chandransh 695 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
696 
    1. There is no order corresponding to an AWB number.
697 
    2. The captured amount for a payment exceeds the total payment.
698 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
699 
 
700 
    Parameters:
701 
     - collectedAmountMap
702 
     - xferBy
703 
     - xferTxnId
704 
     - xferDate
705 
    """
706 
    pass
707 
 
4008 mandeep.dh 708 
  def getTransactionsRequiringExtraProcessing(self, category):
709 
    """
4065 mandeep.dh 710 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 711 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 712 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 713 
 
4008 mandeep.dh 714 
    Parameters:
715 
     - category
716 
    """
717 
    pass
718 
 
719 
  def markTransactionAsProcessed(self, transactionId, category):
720 
    """
721 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 722 
    It essentially deletes the transaction id record for a particular
723 
    processing type category (if present) from DB.
724 
    This is currently used by CRM application.
4008 mandeep.dh 725 
 
726 
    Parameters:
727 
     - transactionId
728 
     - category
729 
    """
730 
    pass
731 
 
4018 chandransh 732 
  def getItemWiseRiskyOrdersCount(self, ):
733 
    """
734 
    Returns a map containing the number of risky orders keyed by item id. A risky order
735 
    is defined as one whose shipping date is about to expire.
736 
    """
737 
    pass
4008 mandeep.dh 738 
 
4295 varun.gupt 739 
  def getOrdersForItemIds(self, itemIds):
740 
    """
741 
    Returns a list of all orders which have items with given id
742 
 
743 
    Parameters:
744 
     - itemIds
745 
    """
746 
    pass
747 
 
4247 rajveer 748 
  def markOrderCancellationRequestReceived(self, orderId):
749 
    """
750 
    Mark order as cancellation request received. If customer sends request of cancellation of
751 
    a particular order, this method will be called. It will just change status of the order
752 
    depending on its current status. It also records the previous status, so that we can move
753 
    back to that status if cancellation request is denied.
4018 chandransh 754 
 
4247 rajveer 755 
    Parameters:
756 
     - orderId
757 
    """
758 
    pass
759 
 
760 
  def markOrderCancellationRequestConfirmed(self, orderId):
761 
    """
762 
    If we decide to to cancel order, CRM will call this method to move the status of order to
763 
    cancellation request confirmed. After this OM will be able to cancel the order.
764 
 
765 
    Parameters:
766 
     - orderId
767 
    """
768 
    pass
769 
 
770 
  def markOrderCancellationRequestDenied(self, orderId):
771 
    """
772 
    If we decide to not to cancel order, we will move the order ro previous status.
773 
 
774 
    Parameters:
775 
     - orderId
776 
    """
777 
    pass
778 
 
4258 rajveer 779 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 780 
    """
4258 rajveer 781 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
782 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 783 
 
784 
    Parameters:
4258 rajveer 785 
     - transactionId
4247 rajveer 786 
    """
787 
    pass
788 
 
4259 anupam.sin 789 
  def refundTransaction(self, transactionId, refundedBy, reason):
790 
    """
791 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
792 
    need to be cancelled
4247 rajveer 793 
 
4259 anupam.sin 794 
    Parameters:
795 
     - transactionId
796 
     - refundedBy
797 
     - reason
798 
    """
799 
    pass
800 
 
4324 mandeep.dh 801 
  def updateShipmentAddress(self, orderId, addressId):
802 
    """
803 
    Updates shipment address of an order. Delivery and shipping date estimates
804 
    etc. are also updated here.
805 
 
806 
    Throws TransactionServiceException in case address change is not
807 
    possible due to certain reasons such as new pincode in address is
808 
    not serviceable etc.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - addressId
813 
    """
814 
    pass
815 
 
4285 rajveer 816 
  def acceptOrdersForItemId(self, itemId, inventory):
817 
    """
818 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
819 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 820 
 
4285 rajveer 821 
    Parameters:
822 
     - itemId
823 
     - inventory
824 
    """
825 
    pass
826 
 
4369 rajveer 827 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 828 
    """
829 
    Parameters:
830 
     - vendorId
831 
     - itemId
832 
     - quantity
833 
     - estimate
4369 rajveer 834 
     - isReminder
4303 rajveer 835 
    """
836 
    pass
4285 rajveer 837 
 
4369 rajveer 838 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 839 
    """
840 
    Parameters:
841 
     - vendorId
842 
     - itemId
843 
     - quantity
844 
     - estimate
4369 rajveer 845 
     - isReminder
4303 rajveer 846 
    """
847 
    pass
848 
 
4369 rajveer 849 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 850 
    """
851 
    Parameters:
852 
     - vendorId
853 
     - itemId
854 
     - quantity
855 
     - estimate
4369 rajveer 856 
     - isReminder
4303 rajveer 857 
    """
858 
    pass
859 
 
4369 rajveer 860 
  def markOrdersAsTimeout(self, vendorId):
861 
    """
862 
    Parameters:
863 
     - vendorId
864 
    """
865 
    pass
4303 rajveer 866 
 
4386 anupam.sin 867 
  def getOrderForAwb(self, awb):
868 
    """
869 
    Returns the order corresponding to an AWB number
4369 rajveer 870 
 
4386 anupam.sin 871 
    Parameters:
872 
     - awb
873 
    """
874 
    pass
875 
 
4506 phani.kuma 876 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
877 
    """
878 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 879 
 
4506 phani.kuma 880 
    Parameters:
881 
     - logistics_provider_id
882 
     - order_status
883 
    """
884 
    pass
885 
 
886 
 
3376 rajveer 887 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 888 
  def __init__(self, iprot, oprot=None):
3376 rajveer 889 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 890 
 
891 
  def createTransaction(self, transaction):
892 
    """
893 
    Parameters:
894 
     - transaction
895 
    """
896 
    self.send_createTransaction(transaction)
132 ashish 897 
    return self.recv_createTransaction()
94 ashish 898 
 
899 
  def send_createTransaction(self, transaction):
900 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
901 
    args = createTransaction_args()
902 
    args.transaction = transaction
903 
    args.write(self._oprot)
904 
    self._oprot.writeMessageEnd()
905 
    self._oprot.trans.flush()
906 
 
907 
  def recv_createTransaction(self, ):
908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
909 
    if mtype == TMessageType.EXCEPTION:
910 
      x = TApplicationException()
911 
      x.read(self._iprot)
912 
      self._iprot.readMessageEnd()
913 
      raise x
914 
    result = createTransaction_result()
915 
    result.read(self._iprot)
916 
    self._iprot.readMessageEnd()
3431 rajveer 917 
    if result.success is not None:
132 ashish 918 
      return result.success
3431 rajveer 919 
    if result.ex is not None:
94 ashish 920 
      raise result.ex
132 ashish 921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 922 
 
923 
  def getTransaction(self, id):
924 
    """
925 
    Parameters:
926 
     - id
927 
    """
928 
    self.send_getTransaction(id)
929 
    return self.recv_getTransaction()
930 
 
931 
  def send_getTransaction(self, id):
932 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
933 
    args = getTransaction_args()
934 
    args.id = id
935 
    args.write(self._oprot)
936 
    self._oprot.writeMessageEnd()
937 
    self._oprot.trans.flush()
938 
 
939 
  def recv_getTransaction(self, ):
940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
941 
    if mtype == TMessageType.EXCEPTION:
942 
      x = TApplicationException()
943 
      x.read(self._iprot)
944 
      self._iprot.readMessageEnd()
945 
      raise x
946 
    result = getTransaction_result()
947 
    result.read(self._iprot)
948 
    self._iprot.readMessageEnd()
3431 rajveer 949 
    if result.success is not None:
94 ashish 950 
      return result.success
3431 rajveer 951 
    if result.ex is not None:
94 ashish 952 
      raise result.ex
953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
954 
 
955 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
956 
    """
957 
    Parameters:
958 
     - customerId
959 
     - from_date
960 
     - to_date
961 
     - status
962 
    """
963 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
964 
    return self.recv_getTransactionsForCustomer()
965 
 
966 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
967 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
968 
    args = getTransactionsForCustomer_args()
969 
    args.customerId = customerId
970 
    args.from_date = from_date
971 
    args.to_date = to_date
972 
    args.status = status
973 
    args.write(self._oprot)
974 
    self._oprot.writeMessageEnd()
975 
    self._oprot.trans.flush()
976 
 
977 
  def recv_getTransactionsForCustomer(self, ):
978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
979 
    if mtype == TMessageType.EXCEPTION:
980 
      x = TApplicationException()
981 
      x.read(self._iprot)
982 
      self._iprot.readMessageEnd()
983 
      raise x
984 
    result = getTransactionsForCustomer_result()
985 
    result.read(self._iprot)
986 
    self._iprot.readMessageEnd()
3431 rajveer 987 
    if result.success is not None:
94 ashish 988 
      return result.success
3431 rajveer 989 
    if result.ex is not None:
94 ashish 990 
      raise result.ex
991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
992 
 
132 ashish 993 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
994 
    """
995 
    Parameters:
996 
     - shoppingCartId
997 
    """
998 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
999 
    return self.recv_getTransactionsForShoppingCartId()
1000 
 
1001 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1002 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1003 
    args = getTransactionsForShoppingCartId_args()
1004 
    args.shoppingCartId = shoppingCartId
1005 
    args.write(self._oprot)
1006 
    self._oprot.writeMessageEnd()
1007 
    self._oprot.trans.flush()
1008 
 
1009 
  def recv_getTransactionsForShoppingCartId(self, ):
1010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1011 
    if mtype == TMessageType.EXCEPTION:
1012 
      x = TApplicationException()
1013 
      x.read(self._iprot)
1014 
      self._iprot.readMessageEnd()
1015 
      raise x
1016 
    result = getTransactionsForShoppingCartId_result()
1017 
    result.read(self._iprot)
1018 
    self._iprot.readMessageEnd()
3431 rajveer 1019 
    if result.success is not None:
132 ashish 1020 
      return result.success
3431 rajveer 1021 
    if result.ex is not None:
132 ashish 1022 
      raise result.ex
1023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1024 
 
94 ashish 1025 
  def getTransactionStatus(self, transactionId):
1026 
    """
1027 
    Parameters:
1028 
     - transactionId
1029 
    """
1030 
    self.send_getTransactionStatus(transactionId)
1031 
    return self.recv_getTransactionStatus()
1032 
 
1033 
  def send_getTransactionStatus(self, transactionId):
1034 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1035 
    args = getTransactionStatus_args()
1036 
    args.transactionId = transactionId
1037 
    args.write(self._oprot)
1038 
    self._oprot.writeMessageEnd()
1039 
    self._oprot.trans.flush()
1040 
 
1041 
  def recv_getTransactionStatus(self, ):
1042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1043 
    if mtype == TMessageType.EXCEPTION:
1044 
      x = TApplicationException()
1045 
      x.read(self._iprot)
1046 
      self._iprot.readMessageEnd()
1047 
      raise x
1048 
    result = getTransactionStatus_result()
1049 
    result.read(self._iprot)
1050 
    self._iprot.readMessageEnd()
3431 rajveer 1051 
    if result.success is not None:
94 ashish 1052 
      return result.success
3431 rajveer 1053 
    if result.ex is not None:
94 ashish 1054 
      raise result.ex
1055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1056 
 
1057 
  def changeTransactionStatus(self, transactionId, status, description):
1058 
    """
1059 
    Parameters:
1060 
     - transactionId
1061 
     - status
1062 
     - description
1063 
    """
1064 
    self.send_changeTransactionStatus(transactionId, status, description)
1065 
    return self.recv_changeTransactionStatus()
1066 
 
1067 
  def send_changeTransactionStatus(self, transactionId, status, description):
1068 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1069 
    args = changeTransactionStatus_args()
1070 
    args.transactionId = transactionId
1071 
    args.status = status
1072 
    args.description = description
1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
1077 
  def recv_changeTransactionStatus(self, ):
1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
1084 
    result = changeTransactionStatus_result()
1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
3431 rajveer 1087 
    if result.success is not None:
94 ashish 1088 
      return result.success
3431 rajveer 1089 
    if result.ex is not None:
94 ashish 1090 
      raise result.ex
1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1092 
 
1398 varun.gupt 1093 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1094 
    """
1095 
    Parameters:
1096 
     - transactionId
1097 
    """
1398 varun.gupt 1098 
    self.send_enqueueTransactionInfoEmail(transactionId)
1099 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1100 
 
1398 varun.gupt 1101 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1102 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1103 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1104 
    args.transactionId = transactionId
1105 
    args.write(self._oprot)
1106 
    self._oprot.writeMessageEnd()
1107 
    self._oprot.trans.flush()
1108 
 
1398 varun.gupt 1109 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1111 
    if mtype == TMessageType.EXCEPTION:
1112 
      x = TApplicationException()
1113 
      x.read(self._iprot)
1114 
      self._iprot.readMessageEnd()
1115 
      raise x
1398 varun.gupt 1116 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1117 
    result.read(self._iprot)
1118 
    self._iprot.readMessageEnd()
3431 rajveer 1119 
    if result.success is not None:
1382 varun.gupt 1120 
      return result.success
3431 rajveer 1121 
    if result.ex is not None:
1382 varun.gupt 1122 
      raise result.ex
1398 varun.gupt 1123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1124 
 
483 rajveer 1125 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1126 
    """
1127 
    Parameters:
483 rajveer 1128 
     - status
1129 
     - from_date
1130 
     - to_date
1131 
     - warehouse_id
94 ashish 1132 
    """
483 rajveer 1133 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1134 
    return self.recv_getAllOrders()
94 ashish 1135 
 
483 rajveer 1136 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1137 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1138 
    args = getAllOrders_args()
1139 
    args.status = status
1140 
    args.from_date = from_date
1141 
    args.to_date = to_date
1142 
    args.warehouse_id = warehouse_id
94 ashish 1143 
    args.write(self._oprot)
1144 
    self._oprot.writeMessageEnd()
1145 
    self._oprot.trans.flush()
1146 
 
483 rajveer 1147 
  def recv_getAllOrders(self, ):
94 ashish 1148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1149 
    if mtype == TMessageType.EXCEPTION:
1150 
      x = TApplicationException()
1151 
      x.read(self._iprot)
1152 
      self._iprot.readMessageEnd()
1153 
      raise x
483 rajveer 1154 
    result = getAllOrders_result()
94 ashish 1155 
    result.read(self._iprot)
1156 
    self._iprot.readMessageEnd()
3431 rajveer 1157 
    if result.success is not None:
94 ashish 1158 
      return result.success
3431 rajveer 1159 
    if result.ex is not None:
94 ashish 1160 
      raise result.ex
483 rajveer 1161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1162 
 
4133 chandransh 1163 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1164 
    """
1165 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1166 
    Pass the status as null and the limit as 0 to ignore them.
1167 
 
1168 
    Parameters:
1169 
     - statuses
1170 
     - offset
1171 
     - limit
1172 
     - warehouse_id
1173 
    """
1174 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1175 
    return self.recv_getOrdersInBatch()
1176 
 
1177 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1178 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1179 
    args = getOrdersInBatch_args()
1180 
    args.statuses = statuses
1181 
    args.offset = offset
1182 
    args.limit = limit
1183 
    args.warehouse_id = warehouse_id
1184 
    args.write(self._oprot)
1185 
    self._oprot.writeMessageEnd()
1186 
    self._oprot.trans.flush()
1187 
 
1188 
  def recv_getOrdersInBatch(self, ):
1189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1190 
    if mtype == TMessageType.EXCEPTION:
1191 
      x = TApplicationException()
1192 
      x.read(self._iprot)
1193 
      self._iprot.readMessageEnd()
1194 
      raise x
1195 
    result = getOrdersInBatch_result()
1196 
    result.read(self._iprot)
1197 
    self._iprot.readMessageEnd()
1198 
    if result.success is not None:
1199 
      return result.success
1200 
    if result.ex is not None:
1201 
      raise result.ex
1202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1203 
 
1204 
  def getOrderCount(self, statuses, warehouseId):
1205 
    """
1206 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1207 
 
1208 
    Parameters:
1209 
     - statuses
1210 
     - warehouseId
1211 
    """
1212 
    self.send_getOrderCount(statuses, warehouseId)
1213 
    return self.recv_getOrderCount()
1214 
 
1215 
  def send_getOrderCount(self, statuses, warehouseId):
1216 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1217 
    args = getOrderCount_args()
1218 
    args.statuses = statuses
1219 
    args.warehouseId = warehouseId
1220 
    args.write(self._oprot)
1221 
    self._oprot.writeMessageEnd()
1222 
    self._oprot.trans.flush()
1223 
 
1224 
  def recv_getOrderCount(self, ):
1225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1226 
    if mtype == TMessageType.EXCEPTION:
1227 
      x = TApplicationException()
1228 
      x.read(self._iprot)
1229 
      self._iprot.readMessageEnd()
1230 
      raise x
1231 
    result = getOrderCount_result()
1232 
    result.read(self._iprot)
1233 
    self._iprot.readMessageEnd()
1234 
    if result.success is not None:
1235 
      return result.success
1236 
    if result.ex is not None:
1237 
      raise result.ex
1238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1239 
 
999 varun.gupt 1240 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1241 
    """
1132 chandransh 1242 
    Returns orders within a range of their billing dates
3431 rajveer 1243 
 
999 varun.gupt 1244 
    Parameters:
1245 
     - status
1246 
     - start_billing_date
1247 
     - end_billing_date
1248 
     - warehouse_id
1249 
    """
1250 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1251 
    return self.recv_getOrdersByBillingDate()
1252 
 
1253 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1254 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1255 
    args = getOrdersByBillingDate_args()
1256 
    args.status = status
1257 
    args.start_billing_date = start_billing_date
1258 
    args.end_billing_date = end_billing_date
1259 
    args.warehouse_id = warehouse_id
1260 
    args.write(self._oprot)
1261 
    self._oprot.writeMessageEnd()
1262 
    self._oprot.trans.flush()
1263 
 
1264 
  def recv_getOrdersByBillingDate(self, ):
1265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1266 
    if mtype == TMessageType.EXCEPTION:
1267 
      x = TApplicationException()
1268 
      x.read(self._iprot)
1269 
      self._iprot.readMessageEnd()
1270 
      raise x
1271 
    result = getOrdersByBillingDate_result()
1272 
    result.read(self._iprot)
1273 
    self._iprot.readMessageEnd()
3431 rajveer 1274 
    if result.success is not None:
999 varun.gupt 1275 
      return result.success
3431 rajveer 1276 
    if result.ex is not None:
999 varun.gupt 1277 
      raise result.ex
1278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1279 
 
3451 chandransh 1280 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1281 
    """
1282 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1283 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1284 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1285 
 
3427 chandransh 1286 
    Parameters:
1287 
     - fromShippingDate
1288 
     - toShippingDate
1289 
     - providerId
1290 
     - warehouseId
3451 chandransh 1291 
     - cod
3427 chandransh 1292 
    """
3451 chandransh 1293 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1294 
    return self.recv_getOrdersByShippingDate()
1295 
 
3451 chandransh 1296 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1297 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1298 
    args = getOrdersByShippingDate_args()
1299 
    args.fromShippingDate = fromShippingDate
1300 
    args.toShippingDate = toShippingDate
1301 
    args.providerId = providerId
1302 
    args.warehouseId = warehouseId
3451 chandransh 1303 
    args.cod = cod
3427 chandransh 1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getOrdersByShippingDate(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getOrdersByShippingDate_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
3431 rajveer 1318 
    if result.success is not None:
3427 chandransh 1319 
      return result.success
3431 rajveer 1320 
    if result.ex is not None:
3427 chandransh 1321 
      raise result.ex
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1323 
 
1382 varun.gupt 1324 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1325 
    """
1326 
    Returns order ids for orders which can be returned
3431 rajveer 1327 
 
1382 varun.gupt 1328 
    Parameters:
1329 
     - customer_id
1330 
     - limit
1331 
    """
1332 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1333 
    return self.recv_getReturnableOrdersForCustomer()
1334 
 
1335 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1336 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1337 
    args = getReturnableOrdersForCustomer_args()
1338 
    args.customer_id = customer_id
1339 
    args.limit = limit
1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
1344 
  def recv_getReturnableOrdersForCustomer(self, ):
1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
1351 
    result = getReturnableOrdersForCustomer_result()
1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
3431 rajveer 1354 
    if result.success is not None:
1382 varun.gupt 1355 
      return result.success
3431 rajveer 1356 
    if result.ex is not None:
1382 varun.gupt 1357 
      raise result.ex
1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1359 
 
1360 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1361 
    """
1362 
    Returns order ids for orders which can be cancelled
3431 rajveer 1363 
 
1382 varun.gupt 1364 
    Parameters:
1365 
     - customer_id
1366 
     - limit
1367 
    """
1368 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1369 
    return self.recv_getCancellableOrdersForCustomer()
1370 
 
1371 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1372 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1373 
    args = getCancellableOrdersForCustomer_args()
1374 
    args.customer_id = customer_id
1375 
    args.limit = limit
1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getCancellableOrdersForCustomer(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getCancellableOrdersForCustomer_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
3431 rajveer 1390 
    if result.success is not None:
1382 varun.gupt 1391 
      return result.success
3431 rajveer 1392 
    if result.ex is not None:
1382 varun.gupt 1393 
      raise result.ex
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1395 
 
483 rajveer 1396 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1397 
    """
1398 
    Parameters:
483 rajveer 1399 
     - orderId
1400 
     - status
1401 
     - description
94 ashish 1402 
    """
483 rajveer 1403 
    self.send_changeOrderStatus(orderId, status, description)
1404 
    return self.recv_changeOrderStatus()
94 ashish 1405 
 
483 rajveer 1406 
  def send_changeOrderStatus(self, orderId, status, description):
1407 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1408 
    args = changeOrderStatus_args()
1409 
    args.orderId = orderId
1410 
    args.status = status
1411 
    args.description = description
94 ashish 1412 
    args.write(self._oprot)
1413 
    self._oprot.writeMessageEnd()
1414 
    self._oprot.trans.flush()
1415 
 
483 rajveer 1416 
  def recv_changeOrderStatus(self, ):
94 ashish 1417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1418 
    if mtype == TMessageType.EXCEPTION:
1419 
      x = TApplicationException()
1420 
      x.read(self._iprot)
1421 
      self._iprot.readMessageEnd()
1422 
      raise x
483 rajveer 1423 
    result = changeOrderStatus_result()
94 ashish 1424 
    result.read(self._iprot)
1425 
    self._iprot.readMessageEnd()
3431 rajveer 1426 
    if result.success is not None:
94 ashish 1427 
      return result.success
3431 rajveer 1428 
    if result.ex is not None:
94 ashish 1429 
      raise result.ex
483 rajveer 1430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1431 
 
1528 ankur.sing 1432 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1433 
    """
1528 ankur.sing 1434 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1435 
    only user who owns the transaction can view its order details.
3431 rajveer 1436 
 
94 ashish 1437 
    Parameters:
1438 
     - transactionId
1528 ankur.sing 1439 
     - customerId
94 ashish 1440 
    """
1528 ankur.sing 1441 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1442 
    return self.recv_getOrdersForTransaction()
94 ashish 1443 
 
1528 ankur.sing 1444 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1445 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1446 
    args = getOrdersForTransaction_args()
94 ashish 1447 
    args.transactionId = transactionId
1528 ankur.sing 1448 
    args.customerId = customerId
94 ashish 1449 
    args.write(self._oprot)
1450 
    self._oprot.writeMessageEnd()
1451 
    self._oprot.trans.flush()
1452 
 
483 rajveer 1453 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1455 
    if mtype == TMessageType.EXCEPTION:
1456 
      x = TApplicationException()
1457 
      x.read(self._iprot)
1458 
      self._iprot.readMessageEnd()
1459 
      raise x
483 rajveer 1460 
    result = getOrdersForTransaction_result()
94 ashish 1461 
    result.read(self._iprot)
1462 
    self._iprot.readMessageEnd()
3431 rajveer 1463 
    if result.success is not None:
94 ashish 1464 
      return result.success
3431 rajveer 1465 
    if result.ex is not None:
94 ashish 1466 
      raise result.ex
483 rajveer 1467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1468 
 
3014 chandransh 1469 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1470 
    """
3014 chandransh 1471 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1472 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1473 
 
94 ashish 1474 
    Parameters:
483 rajveer 1475 
     - customerId
1476 
     - from_date
1477 
     - to_date
3014 chandransh 1478 
     - statuses
94 ashish 1479 
    """
3014 chandransh 1480 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1481 
    return self.recv_getOrdersForCustomer()
94 ashish 1482 
 
3014 chandransh 1483 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1484 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1485 
    args = getOrdersForCustomer_args()
1486 
    args.customerId = customerId
1487 
    args.from_date = from_date
1488 
    args.to_date = to_date
3014 chandransh 1489 
    args.statuses = statuses
94 ashish 1490 
    args.write(self._oprot)
1491 
    self._oprot.writeMessageEnd()
1492 
    self._oprot.trans.flush()
1493 
 
483 rajveer 1494 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1496 
    if mtype == TMessageType.EXCEPTION:
1497 
      x = TApplicationException()
1498 
      x.read(self._iprot)
1499 
      self._iprot.readMessageEnd()
1500 
      raise x
483 rajveer 1501 
    result = getOrdersForCustomer_result()
94 ashish 1502 
    result.read(self._iprot)
1503 
    self._iprot.readMessageEnd()
3431 rajveer 1504 
    if result.success is not None:
94 ashish 1505 
      return result.success
3431 rajveer 1506 
    if result.ex is not None:
94 ashish 1507 
      raise result.ex
483 rajveer 1508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1509 
 
483 rajveer 1510 
  def createOrder(self, order):
94 ashish 1511 
    """
1512 
    Parameters:
483 rajveer 1513 
     - order
94 ashish 1514 
    """
483 rajveer 1515 
    self.send_createOrder(order)
1516 
    return self.recv_createOrder()
94 ashish 1517 
 
483 rajveer 1518 
  def send_createOrder(self, order):
1519 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1520 
    args = createOrder_args()
1521 
    args.order = order
94 ashish 1522 
    args.write(self._oprot)
1523 
    self._oprot.writeMessageEnd()
1524 
    self._oprot.trans.flush()
1525 
 
483 rajveer 1526 
  def recv_createOrder(self, ):
94 ashish 1527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1528 
    if mtype == TMessageType.EXCEPTION:
1529 
      x = TApplicationException()
1530 
      x.read(self._iprot)
1531 
      self._iprot.readMessageEnd()
1532 
      raise x
483 rajveer 1533 
    result = createOrder_result()
94 ashish 1534 
    result.read(self._iprot)
1535 
    self._iprot.readMessageEnd()
3431 rajveer 1536 
    if result.success is not None:
94 ashish 1537 
      return result.success
3431 rajveer 1538 
    if result.ex is not None:
94 ashish 1539 
      raise result.ex
483 rajveer 1540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1541 
 
483 rajveer 1542 
  def getOrder(self, id):
94 ashish 1543 
    """
1544 
    Parameters:
483 rajveer 1545 
     - id
94 ashish 1546 
    """
483 rajveer 1547 
    self.send_getOrder(id)
1548 
    return self.recv_getOrder()
94 ashish 1549 
 
483 rajveer 1550 
  def send_getOrder(self, id):
1551 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1552 
    args = getOrder_args()
1553 
    args.id = id
94 ashish 1554 
    args.write(self._oprot)
1555 
    self._oprot.writeMessageEnd()
1556 
    self._oprot.trans.flush()
1557 
 
483 rajveer 1558 
  def recv_getOrder(self, ):
94 ashish 1559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1560 
    if mtype == TMessageType.EXCEPTION:
1561 
      x = TApplicationException()
1562 
      x.read(self._iprot)
1563 
      self._iprot.readMessageEnd()
1564 
      raise x
483 rajveer 1565 
    result = getOrder_result()
94 ashish 1566 
    result.read(self._iprot)
1567 
    self._iprot.readMessageEnd()
3431 rajveer 1568 
    if result.success is not None:
94 ashish 1569 
      return result.success
3431 rajveer 1570 
    if result.ex is not None:
94 ashish 1571 
      raise result.ex
483 rajveer 1572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1573 
 
483 rajveer 1574 
  def getLineItemsForOrder(self, orderId):
94 ashish 1575 
    """
1576 
    Parameters:
483 rajveer 1577 
     - orderId
94 ashish 1578 
    """
483 rajveer 1579 
    self.send_getLineItemsForOrder(orderId)
1580 
    return self.recv_getLineItemsForOrder()
94 ashish 1581 
 
483 rajveer 1582 
  def send_getLineItemsForOrder(self, orderId):
1583 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1584 
    args = getLineItemsForOrder_args()
1585 
    args.orderId = orderId
94 ashish 1586 
    args.write(self._oprot)
1587 
    self._oprot.writeMessageEnd()
1588 
    self._oprot.trans.flush()
1589 
 
483 rajveer 1590 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1592 
    if mtype == TMessageType.EXCEPTION:
1593 
      x = TApplicationException()
1594 
      x.read(self._iprot)
1595 
      self._iprot.readMessageEnd()
1596 
      raise x
483 rajveer 1597 
    result = getLineItemsForOrder_result()
94 ashish 1598 
    result.read(self._iprot)
1599 
    self._iprot.readMessageEnd()
3431 rajveer 1600 
    if result.success is not None:
94 ashish 1601 
      return result.success
3431 rajveer 1602 
    if result.ex is not None:
94 ashish 1603 
      raise result.ex
483 rajveer 1604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1605 
 
1528 ankur.sing 1606 
  def getOrderForCustomer(self, orderId, customerId):
1607 
    """
1608 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1609 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1610 
 
1528 ankur.sing 1611 
    Parameters:
1612 
     - orderId
1613 
     - customerId
1614 
    """
1615 
    self.send_getOrderForCustomer(orderId, customerId)
1616 
    return self.recv_getOrderForCustomer()
1617 
 
1618 
  def send_getOrderForCustomer(self, orderId, customerId):
1619 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1620 
    args = getOrderForCustomer_args()
1621 
    args.orderId = orderId
1622 
    args.customerId = customerId
1623 
    args.write(self._oprot)
1624 
    self._oprot.writeMessageEnd()
1625 
    self._oprot.trans.flush()
1626 
 
1627 
  def recv_getOrderForCustomer(self, ):
1628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1629 
    if mtype == TMessageType.EXCEPTION:
1630 
      x = TApplicationException()
1631 
      x.read(self._iprot)
1632 
      self._iprot.readMessageEnd()
1633 
      raise x
1634 
    result = getOrderForCustomer_result()
1635 
    result.read(self._iprot)
1636 
    self._iprot.readMessageEnd()
3431 rajveer 1637 
    if result.success is not None:
1528 ankur.sing 1638 
      return result.success
3431 rajveer 1639 
    if result.ex is not None:
1528 ankur.sing 1640 
      raise result.ex
1641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1642 
 
4444 rajveer 1643 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1644 
    """
1645 
    Parameters:
4394 rajveer 1646 
     - type
4444 rajveer 1647 
     - warehouseId
4394 rajveer 1648 
     - status
1649 
     - timestamp
3064 chandransh 1650 
    """
4444 rajveer 1651 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1652 
    return self.recv_getAlerts()
1653 
 
4444 rajveer 1654 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1655 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1656 
    args = getAlerts_args()
4394 rajveer 1657 
    args.type = type
4444 rajveer 1658 
    args.warehouseId = warehouseId
4394 rajveer 1659 
    args.status = status
1660 
    args.timestamp = timestamp
3064 chandransh 1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
1665 
  def recv_getAlerts(self, ):
1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
1672 
    result = getAlerts_result()
1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
3431 rajveer 1675 
    if result.success is not None:
3064 chandransh 1676 
      return result.success
1677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1678 
 
4444 rajveer 1679 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1680 
    """
1681 
    Parameters:
1682 
     - type
4444 rajveer 1683 
     - warehouseId
4394 rajveer 1684 
     - description
3064 chandransh 1685 
    """
4444 rajveer 1686 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1687 
    self.recv_addAlert()
3064 chandransh 1688 
 
4444 rajveer 1689 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1690 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1691 
    args = addAlert_args()
3064 chandransh 1692 
    args.type = type
4444 rajveer 1693 
    args.warehouseId = warehouseId
4394 rajveer 1694 
    args.description = description
3064 chandransh 1695 
    args.write(self._oprot)
1696 
    self._oprot.writeMessageEnd()
1697 
    self._oprot.trans.flush()
1698 
 
4394 rajveer 1699 
  def recv_addAlert(self, ):
3064 chandransh 1700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1701 
    if mtype == TMessageType.EXCEPTION:
1702 
      x = TApplicationException()
1703 
      x.read(self._iprot)
1704 
      self._iprot.readMessageEnd()
1705 
      raise x
4394 rajveer 1706 
    result = addAlert_result()
3064 chandransh 1707 
    result.read(self._iprot)
1708 
    self._iprot.readMessageEnd()
1709 
    return
1710 
 
4444 rajveer 1711 
  def markAlertsAsSeen(self, warehouseId):
1712 
    """
1713 
    Parameters:
1714 
     - warehouseId
1715 
    """
1716 
    self.send_markAlertsAsSeen(warehouseId)
1717 
    self.recv_markAlertsAsSeen()
1718 
 
1719 
  def send_markAlertsAsSeen(self, warehouseId):
1720 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1721 
    args = markAlertsAsSeen_args()
1722 
    args.warehouseId = warehouseId
1723 
    args.write(self._oprot)
1724 
    self._oprot.writeMessageEnd()
1725 
    self._oprot.trans.flush()
1726 
 
1727 
  def recv_markAlertsAsSeen(self, ):
1728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1729 
    if mtype == TMessageType.EXCEPTION:
1730 
      x = TApplicationException()
1731 
      x.read(self._iprot)
1732 
      self._iprot.readMessageEnd()
1733 
      raise x
1734 
    result = markAlertsAsSeen_result()
1735 
    result.read(self._iprot)
1736 
    self._iprot.readMessageEnd()
1737 
    return
1738 
 
3064 chandransh 1739 
  def getValidOrderCount(self, ):
1740 
    """
1741 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1742 
    """
1743 
    self.send_getValidOrderCount()
1744 
    return self.recv_getValidOrderCount()
1745 
 
1746 
  def send_getValidOrderCount(self, ):
1747 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1748 
    args = getValidOrderCount_args()
1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getValidOrderCount(self, ):
1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
1760 
    result = getValidOrderCount_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
3431 rajveer 1763 
    if result.success is not None:
3064 chandransh 1764 
      return result.success
1765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1766 
 
1767 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1768 
    """
1769 
    Returns the number of distinct customers who have done successful transactions
1770 
    """
1771 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1772 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1773 
 
1774 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1775 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1776 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
3064 chandransh 1792 
      return result.success
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1794 
 
1795 
  def getValidOrdersAmountRange(self, ):
1796 
    """
1797 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1798 
    List contains two values, first minimum amount and second maximum amount.
1799 
    """
1800 
    self.send_getValidOrdersAmountRange()
1801 
    return self.recv_getValidOrdersAmountRange()
1802 
 
1803 
  def send_getValidOrdersAmountRange(self, ):
1804 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1805 
    args = getValidOrdersAmountRange_args()
1806 
    args.write(self._oprot)
1807 
    self._oprot.writeMessageEnd()
1808 
    self._oprot.trans.flush()
1809 
 
1810 
  def recv_getValidOrdersAmountRange(self, ):
1811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1812 
    if mtype == TMessageType.EXCEPTION:
1813 
      x = TApplicationException()
1814 
      x.read(self._iprot)
1815 
      self._iprot.readMessageEnd()
1816 
      raise x
1817 
    result = getValidOrdersAmountRange_result()
1818 
    result.read(self._iprot)
1819 
    self._iprot.readMessageEnd()
3431 rajveer 1820 
    if result.success is not None:
3064 chandransh 1821 
      return result.success
1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1823 
 
1824 
  def getValidOrders(self, limit):
1825 
    """
1826 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1827 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1828 
 
3064 chandransh 1829 
    Parameters:
1830 
     - limit
1831 
    """
1832 
    self.send_getValidOrders(limit)
1833 
    return self.recv_getValidOrders()
1834 
 
1835 
  def send_getValidOrders(self, limit):
1836 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1837 
    args = getValidOrders_args()
1838 
    args.limit = limit
1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
1843 
  def recv_getValidOrders(self, ):
1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
1850 
    result = getValidOrders_result()
1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
3431 rajveer 1853 
    if result.success is not None:
3064 chandransh 1854 
      return result.success
1855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1856 
 
1220 chandransh 1857 
  def batchOrders(self, warehouseId):
1858 
    """
1859 
    Create a batch of all the pending orders for the given warehouse.
1860 
    The returned list is orderd by created_timestamp.
1861 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1862 
 
1220 chandransh 1863 
    Parameters:
1864 
     - warehouseId
1865 
    """
1866 
    self.send_batchOrders(warehouseId)
1867 
    return self.recv_batchOrders()
1868 
 
1869 
  def send_batchOrders(self, warehouseId):
1870 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1871 
    args = batchOrders_args()
1872 
    args.warehouseId = warehouseId
1873 
    args.write(self._oprot)
1874 
    self._oprot.writeMessageEnd()
1875 
    self._oprot.trans.flush()
1876 
 
1877 
  def recv_batchOrders(self, ):
1878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1879 
    if mtype == TMessageType.EXCEPTION:
1880 
      x = TApplicationException()
1881 
      x.read(self._iprot)
1882 
      self._iprot.readMessageEnd()
1883 
      raise x
1884 
    result = batchOrders_result()
1885 
    result.read(self._iprot)
1886 
    self._iprot.readMessageEnd()
3431 rajveer 1887 
    if result.success is not None:
1220 chandransh 1888 
      return result.success
3431 rajveer 1889 
    if result.ex is not None:
1220 chandransh 1890 
      raise result.ex
1891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1892 
 
1208 chandransh 1893 
  def markOrderAsOutOfStock(self, orderId):
1894 
    """
1895 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1896 
 
1208 chandransh 1897 
    Parameters:
1898 
     - orderId
1899 
    """
1900 
    self.send_markOrderAsOutOfStock(orderId)
1901 
    return self.recv_markOrderAsOutOfStock()
1902 
 
1903 
  def send_markOrderAsOutOfStock(self, orderId):
1904 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1905 
    args = markOrderAsOutOfStock_args()
1906 
    args.orderId = orderId
1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
1911 
  def recv_markOrderAsOutOfStock(self, ):
1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
1918 
    result = markOrderAsOutOfStock_result()
1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
3431 rajveer 1921 
    if result.success is not None:
1208 chandransh 1922 
      return result.success
3431 rajveer 1923 
    if result.ex is not None:
1208 chandransh 1924 
      raise result.ex
1925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1926 
 
3064 chandransh 1927 
  def verifyOrder(self, orderId):
759 chandransh 1928 
    """
3064 chandransh 1929 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1930 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1931 
    used for all other orders as well.
1932 
    Throws an exception if no such order exists.
3431 rajveer 1933 
 
759 chandransh 1934 
    Parameters:
3064 chandransh 1935 
     - orderId
759 chandransh 1936 
    """
3064 chandransh 1937 
    self.send_verifyOrder(orderId)
1938 
    return self.recv_verifyOrder()
759 chandransh 1939 
 
3064 chandransh 1940 
  def send_verifyOrder(self, orderId):
1941 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1942 
    args = verifyOrder_args()
1943 
    args.orderId = orderId
759 chandransh 1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
3064 chandransh 1948 
  def recv_verifyOrder(self, ):
759 chandransh 1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
3064 chandransh 1955 
    result = verifyOrder_result()
759 chandransh 1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
3431 rajveer 1958 
    if result.success is not None:
759 chandransh 1959 
      return result.success
3431 rajveer 1960 
    if result.ex is not None:
759 chandransh 1961 
      raise result.ex
3064 chandransh 1962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1963 
 
3064 chandransh 1964 
  def acceptOrder(self, orderId):
1113 chandransh 1965 
    """
3064 chandransh 1966 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1967 
    given order is not a COD order, it also captures the payment if the same has
1968 
    not been captured.
1969 
    Throws an exception if no such order exists.
3431 rajveer 1970 
 
1113 chandransh 1971 
    Parameters:
3064 chandransh 1972 
     - orderId
1113 chandransh 1973 
    """
3064 chandransh 1974 
    self.send_acceptOrder(orderId)
1975 
    return self.recv_acceptOrder()
1113 chandransh 1976 
 
3064 chandransh 1977 
  def send_acceptOrder(self, orderId):
1978 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1979 
    args = acceptOrder_args()
1980 
    args.orderId = orderId
1113 chandransh 1981 
    args.write(self._oprot)
1982 
    self._oprot.writeMessageEnd()
1983 
    self._oprot.trans.flush()
1984 
 
3064 chandransh 1985 
  def recv_acceptOrder(self, ):
1113 chandransh 1986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1987 
    if mtype == TMessageType.EXCEPTION:
1988 
      x = TApplicationException()
1989 
      x.read(self._iprot)
1990 
      self._iprot.readMessageEnd()
1991 
      raise x
3064 chandransh 1992 
    result = acceptOrder_result()
1113 chandransh 1993 
    result.read(self._iprot)
1994 
    self._iprot.readMessageEnd()
3431 rajveer 1995 
    if result.success is not None:
1113 chandransh 1996 
      return result.success
3431 rajveer 1997 
    if result.ex is not None:
1113 chandransh 1998 
      raise result.ex
3064 chandransh 1999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2000 
 
4283 anupam.sin 2001 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2002 
    """
3064 chandransh 2003 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2004 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2005 
    the IMEI no. if a -1 is supplied.
2006 
    Also, it generates an invoice number for the order, marks the order as
2007 
    BILLED and sets the billing timestamp.
2008 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2009 
 
1135 chandransh 2010 
    Parameters:
3064 chandransh 2011 
     - orderId
2012 
     - invoice_number
4283 anupam.sin 2013 
     - imeiNumber
2014 
     - itemNumber
3064 chandransh 2015 
     - billed_by
4264 rajveer 2016 
     - jacketNumber
4283 anupam.sin 2017 
     - billingType
2018 
     - vendorId
1135 chandransh 2019 
    """
4283 anupam.sin 2020 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2021 
    return self.recv_addBillingDetails()
1135 chandransh 2022 
 
4283 anupam.sin 2023 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2024 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2025 
    args = addBillingDetails_args()
2026 
    args.orderId = orderId
2027 
    args.invoice_number = invoice_number
4283 anupam.sin 2028 
    args.imeiNumber = imeiNumber
2029 
    args.itemNumber = itemNumber
3064 chandransh 2030 
    args.billed_by = billed_by
4264 rajveer 2031 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2032 
    args.billingType = billingType
2033 
    args.vendorId = vendorId
1135 chandransh 2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
3064 chandransh 2038 
  def recv_addBillingDetails(self, ):
1135 chandransh 2039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2040 
    if mtype == TMessageType.EXCEPTION:
2041 
      x = TApplicationException()
2042 
      x.read(self._iprot)
2043 
      self._iprot.readMessageEnd()
2044 
      raise x
3064 chandransh 2045 
    result = addBillingDetails_result()
1135 chandransh 2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
3431 rajveer 2048 
    if result.success is not None:
3064 chandransh 2049 
      return result.success
3431 rajveer 2050 
    if result.ex is not None:
1135 chandransh 2051 
      raise result.ex
3064 chandransh 2052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2053 
 
4579 rajveer 2054 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2055 
    """
2056 
    Add the invoice number to the order.
2057 
 
2058 
    Parameters:
2059 
     - orderId
2060 
     - invoiceNumber
2061 
    """
2062 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2063 
    self.recv_addInvoiceNumber()
2064 
 
2065 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2066 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2067 
    args = addInvoiceNumber_args()
2068 
    args.orderId = orderId
2069 
    args.invoiceNumber = invoiceNumber
2070 
    args.write(self._oprot)
2071 
    self._oprot.writeMessageEnd()
2072 
    self._oprot.trans.flush()
2073 
 
2074 
  def recv_addInvoiceNumber(self, ):
2075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2076 
    if mtype == TMessageType.EXCEPTION:
2077 
      x = TApplicationException()
2078 
      x.read(self._iprot)
2079 
      self._iprot.readMessageEnd()
2080 
      raise x
2081 
    result = addInvoiceNumber_result()
2082 
    result.read(self._iprot)
2083 
    self._iprot.readMessageEnd()
2084 
    if result.ex is not None:
2085 
      raise result.ex
2086 
    return
2087 
 
3064 chandransh 2088 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2089 
    """
3064 chandransh 2090 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2091 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2092 
 
1408 ankur.sing 2093 
    Parameters:
3064 chandransh 2094 
     - warehouseId
1408 ankur.sing 2095 
     - providerId
3064 chandransh 2096 
     - cod
1408 ankur.sing 2097 
    """
3064 chandransh 2098 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2099 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2100 
 
3064 chandransh 2101 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2102 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2103 
    args = markOrdersAsManifested_args()
2104 
    args.warehouseId = warehouseId
1408 ankur.sing 2105 
    args.providerId = providerId
3064 chandransh 2106 
    args.cod = cod
1408 ankur.sing 2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
3064 chandransh 2111 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
3064 chandransh 2118 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
3431 rajveer 2121 
    if result.success is not None:
1408 ankur.sing 2122 
      return result.success
3431 rajveer 2123 
    if result.ex is not None:
3064 chandransh 2124 
      raise result.ex
2125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2126 
 
4410 rajveer 2127 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2128 
    """
2129 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2130 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2131 
 
2132 
    Parameters:
2133 
     - warehouseId
2134 
     - providerId
2135 
     - cod
2136 
    """
2137 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2138 
    return self.recv_markOrdersAsShippedFromWarehouse()
2139 
 
2140 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2141 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2142 
    args = markOrdersAsShippedFromWarehouse_args()
2143 
    args.warehouseId = warehouseId
2144 
    args.providerId = providerId
2145 
    args.cod = cod
2146 
    args.write(self._oprot)
2147 
    self._oprot.writeMessageEnd()
2148 
    self._oprot.trans.flush()
2149 
 
2150 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2152 
    if mtype == TMessageType.EXCEPTION:
2153 
      x = TApplicationException()
2154 
      x.read(self._iprot)
2155 
      self._iprot.readMessageEnd()
2156 
      raise x
2157 
    result = markOrdersAsShippedFromWarehouse_result()
2158 
    result.read(self._iprot)
2159 
    self._iprot.readMessageEnd()
2160 
    if result.success is not None:
2161 
      return result.success
2162 
    if result.ex is not None:
2163 
      raise result.ex
2164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2165 
 
3064 chandransh 2166 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2167 
    """
3064 chandransh 2168 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2169 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2170 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2171 
 
94 ashish 2172 
    Parameters:
3064 chandransh 2173 
     - providerId
2174 
     - pickupDetails
304 ashish 2175 
    """
3064 chandransh 2176 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2177 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2178 
 
3064 chandransh 2179 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2180 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2181 
    args = markOrdersAsPickedUp_args()
2182 
    args.providerId = providerId
2183 
    args.pickupDetails = pickupDetails
304 ashish 2184 
    args.write(self._oprot)
2185 
    self._oprot.writeMessageEnd()
2186 
    self._oprot.trans.flush()
2187 
 
3064 chandransh 2188 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2190 
    if mtype == TMessageType.EXCEPTION:
2191 
      x = TApplicationException()
2192 
      x.read(self._iprot)
2193 
      self._iprot.readMessageEnd()
2194 
      raise x
3064 chandransh 2195 
    result = markOrdersAsPickedUp_result()
304 ashish 2196 
    result.read(self._iprot)
2197 
    self._iprot.readMessageEnd()
3431 rajveer 2198 
    if result.success is not None:
304 ashish 2199 
      return result.success
3431 rajveer 2200 
    if result.ex is not None:
3064 chandransh 2201 
      raise result.ex
2202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2203 
 
3064 chandransh 2204 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2205 
    """
3064 chandransh 2206 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2207 
    the name of the receiver.
2208 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2209 
 
304 ashish 2210 
    Parameters:
3064 chandransh 2211 
     - providerId
2212 
     - deliveredOrders
304 ashish 2213 
    """
3064 chandransh 2214 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2215 
    self.recv_markOrdersAsDelivered()
304 ashish 2216 
 
3064 chandransh 2217 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2218 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2219 
    args = markOrdersAsDelivered_args()
2220 
    args.providerId = providerId
2221 
    args.deliveredOrders = deliveredOrders
304 ashish 2222 
    args.write(self._oprot)
2223 
    self._oprot.writeMessageEnd()
2224 
    self._oprot.trans.flush()
2225 
 
3064 chandransh 2226 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2228 
    if mtype == TMessageType.EXCEPTION:
2229 
      x = TApplicationException()
2230 
      x.read(self._iprot)
2231 
      self._iprot.readMessageEnd()
2232 
      raise x
3064 chandransh 2233 
    result = markOrdersAsDelivered_result()
304 ashish 2234 
    result.read(self._iprot)
2235 
    self._iprot.readMessageEnd()
3431 rajveer 2236 
    if result.ex is not None:
3064 chandransh 2237 
      raise result.ex
304 ashish 2238 
    return
2239 
 
3064 chandransh 2240 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2241 
    """
3064 chandransh 2242 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2243 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2244 
 
3064 chandransh 2245 
    Parameters:
2246 
     - providerId
2247 
     - returnedOrders
1596 ankur.sing 2248 
    """
3064 chandransh 2249 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2250 
    self.recv_markOrdersAsFailed()
304 ashish 2251 
 
3064 chandransh 2252 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2253 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2254 
    args = markOrdersAsFailed_args()
2255 
    args.providerId = providerId
2256 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
3064 chandransh 2261 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
3064 chandransh 2268 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
3431 rajveer 2271 
    if result.ex is not None:
3064 chandransh 2272 
      raise result.ex
2273 
    return
1596 ankur.sing 2274 
 
3064 chandransh 2275 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2276 
    """
3064 chandransh 2277 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2278 
 
3064 chandransh 2279 
    Parameters:
2280 
     - providerId
2281 
     - undeliveredOrders
1627 ankur.sing 2282 
    """
3064 chandransh 2283 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2284 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2285 
 
3064 chandransh 2286 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2287 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2288 
    args = updateNonDeliveryReason_args()
2289 
    args.providerId = providerId
2290 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
3064 chandransh 2295 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
3064 chandransh 2302 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
3431 rajveer 2305 
    if result.ex is not None:
3064 chandransh 2306 
      raise result.ex
2307 
    return
1627 ankur.sing 2308 
 
3064 chandransh 2309 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2310 
    """
3064 chandransh 2311 
    Returns the list of orders whose delivery time has passed but have not been
2312 
    delivered yet for the given provider and warehouse. To get a complete list of
2313 
    undelivered orders, pass them as -1.
2314 
    Returns an empty list if no such orders exist.
3431 rajveer 2315 
 
1886 ankur.sing 2316 
    Parameters:
3064 chandransh 2317 
     - providerId
2318 
     - warehouseId
1886 ankur.sing 2319 
    """
3064 chandransh 2320 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2321 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2322 
 
3064 chandransh 2323 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2324 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2325 
    args = getUndeliveredOrders_args()
2326 
    args.providerId = providerId
2327 
    args.warehouseId = warehouseId
1886 ankur.sing 2328 
    args.write(self._oprot)
2329 
    self._oprot.writeMessageEnd()
2330 
    self._oprot.trans.flush()
2331 
 
3064 chandransh 2332 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2334 
    if mtype == TMessageType.EXCEPTION:
2335 
      x = TApplicationException()
2336 
      x.read(self._iprot)
2337 
      self._iprot.readMessageEnd()
2338 
      raise x
3064 chandransh 2339 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2340 
    result.read(self._iprot)
2341 
    self._iprot.readMessageEnd()
3431 rajveer 2342 
    if result.success is not None:
1886 ankur.sing 2343 
      return result.success
3064 chandransh 2344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2345 
 
2536 chandransh 2346 
  def toggleDOAFlag(self, orderId):
2347 
    """
2348 
    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.
2349 
    Returns the final flag status.
2350 
    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 2351 
 
2536 chandransh 2352 
    Parameters:
2353 
     - orderId
2354 
    """
2355 
    self.send_toggleDOAFlag(orderId)
2356 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2357 
 
2536 chandransh 2358 
  def send_toggleDOAFlag(self, orderId):
2359 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2360 
    args = toggleDOAFlag_args()
2361 
    args.orderId = orderId
2362 
    args.write(self._oprot)
2363 
    self._oprot.writeMessageEnd()
2364 
    self._oprot.trans.flush()
2365 
 
2366 
  def recv_toggleDOAFlag(self, ):
2367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2368 
    if mtype == TMessageType.EXCEPTION:
2369 
      x = TApplicationException()
2370 
      x.read(self._iprot)
2371 
      self._iprot.readMessageEnd()
2372 
      raise x
2373 
    result = toggleDOAFlag_result()
2374 
    result.read(self._iprot)
2375 
    self._iprot.readMessageEnd()
3431 rajveer 2376 
    if result.success is not None:
2536 chandransh 2377 
      return result.success
3431 rajveer 2378 
    if result.ex is not None:
2536 chandransh 2379 
      raise result.ex
2380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2381 
 
4454 rajveer 2382 
  def markOrderDoaRequestReceived(self, orderId):
2383 
    """
2384 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2385 
 
2386 
    Parameters:
2387 
     - orderId
2388 
    """
2389 
    self.send_markOrderDoaRequestReceived(orderId)
2390 
    return self.recv_markOrderDoaRequestReceived()
2391 
 
2392 
  def send_markOrderDoaRequestReceived(self, orderId):
2393 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2394 
    args = markOrderDoaRequestReceived_args()
2395 
    args.orderId = orderId
2396 
    args.write(self._oprot)
2397 
    self._oprot.writeMessageEnd()
2398 
    self._oprot.trans.flush()
2399 
 
2400 
  def recv_markOrderDoaRequestReceived(self, ):
2401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2402 
    if mtype == TMessageType.EXCEPTION:
2403 
      x = TApplicationException()
2404 
      x.read(self._iprot)
2405 
      self._iprot.readMessageEnd()
2406 
      raise x
2407 
    result = markOrderDoaRequestReceived_result()
2408 
    result.read(self._iprot)
2409 
    self._iprot.readMessageEnd()
2410 
    if result.success is not None:
2411 
      return result.success
2412 
    if result.ex is not None:
2413 
      raise result.ex
2414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2415 
 
2416 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2417 
    """
2418 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2419 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2420 
 
2421 
    Parameters:
2422 
     - orderId
2423 
     - isAuthorized
2424 
    """
2425 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2426 
    return self.recv_markOrderDoaRequestAuthorized()
2427 
 
2428 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2429 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2430 
    args = markOrderDoaRequestAuthorized_args()
2431 
    args.orderId = orderId
2432 
    args.isAuthorized = isAuthorized
2433 
    args.write(self._oprot)
2434 
    self._oprot.writeMessageEnd()
2435 
    self._oprot.trans.flush()
2436 
 
2437 
  def recv_markOrderDoaRequestAuthorized(self, ):
2438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2439 
    if mtype == TMessageType.EXCEPTION:
2440 
      x = TApplicationException()
2441 
      x.read(self._iprot)
2442 
      self._iprot.readMessageEnd()
2443 
      raise x
2444 
    result = markOrderDoaRequestAuthorized_result()
2445 
    result.read(self._iprot)
2446 
    self._iprot.readMessageEnd()
2447 
    if result.success is not None:
2448 
      return result.success
2449 
    if result.ex is not None:
2450 
      raise result.ex
2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2452 
 
4488 rajveer 2453 
  def markOrderReturnRequestReceived(self, orderId):
2454 
    """
2455 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2456 
 
2457 
    Parameters:
2458 
     - orderId
2459 
    """
2460 
    self.send_markOrderReturnRequestReceived(orderId)
2461 
    return self.recv_markOrderReturnRequestReceived()
2462 
 
2463 
  def send_markOrderReturnRequestReceived(self, orderId):
2464 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2465 
    args = markOrderReturnRequestReceived_args()
2466 
    args.orderId = orderId
2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
2471 
  def recv_markOrderReturnRequestReceived(self, ):
2472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2473 
    if mtype == TMessageType.EXCEPTION:
2474 
      x = TApplicationException()
2475 
      x.read(self._iprot)
2476 
      self._iprot.readMessageEnd()
2477 
      raise x
2478 
    result = markOrderReturnRequestReceived_result()
2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
2481 
    if result.success is not None:
2482 
      return result.success
2483 
    if result.ex is not None:
2484 
      raise result.ex
2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2486 
 
2487 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2488 
    """
2489 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2490 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2491 
 
2492 
    Parameters:
2493 
     - orderId
2494 
     - isAuthorized
2495 
    """
2496 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2497 
    return self.recv_markOrderReturnRequestAuthorized()
2498 
 
2499 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2500 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2501 
    args = markOrderReturnRequestAuthorized_args()
2502 
    args.orderId = orderId
2503 
    args.isAuthorized = isAuthorized
2504 
    args.write(self._oprot)
2505 
    self._oprot.writeMessageEnd()
2506 
    self._oprot.trans.flush()
2507 
 
2508 
  def recv_markOrderReturnRequestAuthorized(self, ):
2509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2510 
    if mtype == TMessageType.EXCEPTION:
2511 
      x = TApplicationException()
2512 
      x.read(self._iprot)
2513 
      self._iprot.readMessageEnd()
2514 
      raise x
2515 
    result = markOrderReturnRequestAuthorized_result()
2516 
    result.read(self._iprot)
2517 
    self._iprot.readMessageEnd()
2518 
    if result.success is not None:
2519 
      return result.success
2520 
    if result.ex is not None:
2521 
      raise result.ex
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2523 
 
4579 rajveer 2524 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2525 
    """
2526 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2527 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2528 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2529 
    For any other status, it returns false.
2530 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2531 
 
2536 chandransh 2532 
    Parameters:
2533 
     - orderId
4579 rajveer 2534 
     - providerId
2536 chandransh 2535 
    """
4579 rajveer 2536 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2537 
    return self.recv_requestPickupNumber()
2538 
 
4579 rajveer 2539 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2540 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2541 
    args = requestPickupNumber_args()
2542 
    args.orderId = orderId
4579 rajveer 2543 
    args.providerId = providerId
2536 chandransh 2544 
    args.write(self._oprot)
2545 
    self._oprot.writeMessageEnd()
2546 
    self._oprot.trans.flush()
2547 
 
2548 
  def recv_requestPickupNumber(self, ):
2549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2550 
    if mtype == TMessageType.EXCEPTION:
2551 
      x = TApplicationException()
2552 
      x.read(self._iprot)
2553 
      self._iprot.readMessageEnd()
2554 
      raise x
2555 
    result = requestPickupNumber_result()
2556 
    result.read(self._iprot)
2557 
    self._iprot.readMessageEnd()
3431 rajveer 2558 
    if result.success is not None:
2536 chandransh 2559 
      return result.success
3431 rajveer 2560 
    if result.ex is not None:
2536 chandransh 2561 
      raise result.ex
2562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2563 
 
2564 
  def authorizePickup(self, orderId, pickupNumber):
2565 
    """
4452 rajveer 2566 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2567 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2568 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2569 
    	3. Returns true
2591 chandransh 2570 
    If the order is in any other status, it returns false.
2536 chandransh 2571 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2572 
 
2536 chandransh 2573 
    Parameters:
2574 
     - orderId
2575 
     - pickupNumber
2576 
    """
2577 
    self.send_authorizePickup(orderId, pickupNumber)
2578 
    return self.recv_authorizePickup()
2579 
 
2580 
  def send_authorizePickup(self, orderId, pickupNumber):
2581 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2582 
    args = authorizePickup_args()
2583 
    args.orderId = orderId
2584 
    args.pickupNumber = pickupNumber
2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
2589 
  def recv_authorizePickup(self, ):
2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
2596 
    result = authorizePickup_result()
2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
3431 rajveer 2599 
    if result.success is not None:
2536 chandransh 2600 
      return result.success
3431 rajveer 2601 
    if result.ex is not None:
2536 chandransh 2602 
      raise result.ex
2603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2604 
 
2764 chandransh 2605 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2606 
    """
2607 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2608 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2609 
 
2764 chandransh 2610 
    Parameters:
2611 
     - providerId
2612 
     - pickupDetails
2613 
    """
2614 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2615 
    return self.recv_markDoasAsPickedUp()
2616 
 
2617 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2618 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2619 
    args = markDoasAsPickedUp_args()
2620 
    args.providerId = providerId
2621 
    args.pickupDetails = pickupDetails
2622 
    args.write(self._oprot)
2623 
    self._oprot.writeMessageEnd()
2624 
    self._oprot.trans.flush()
2625 
 
2626 
  def recv_markDoasAsPickedUp(self, ):
2627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2628 
    if mtype == TMessageType.EXCEPTION:
2629 
      x = TApplicationException()
2630 
      x.read(self._iprot)
2631 
      self._iprot.readMessageEnd()
2632 
      raise x
2633 
    result = markDoasAsPickedUp_result()
2634 
    result.read(self._iprot)
2635 
    self._iprot.readMessageEnd()
3431 rajveer 2636 
    if result.success is not None:
2764 chandransh 2637 
      return result.success
2638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2639 
 
4479 rajveer 2640 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2641 
    """
4452 rajveer 2642 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 2643 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2644 
    If the order is in any other state, it returns false.
2645 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2646 
 
2591 chandransh 2647 
    Parameters:
2648 
     - orderId
4479 rajveer 2649 
     - receiveCondition
2591 chandransh 2650 
    """
4479 rajveer 2651 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2652 
    return self.recv_receiveReturn()
2536 chandransh 2653 
 
4479 rajveer 2654 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2655 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2656 
    args = receiveReturn_args()
2591 chandransh 2657 
    args.orderId = orderId
4479 rajveer 2658 
    args.receiveCondition = receiveCondition
2591 chandransh 2659 
    args.write(self._oprot)
2660 
    self._oprot.writeMessageEnd()
2661 
    self._oprot.trans.flush()
2662 
 
2616 chandransh 2663 
  def recv_receiveReturn(self, ):
2591 chandransh 2664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2665 
    if mtype == TMessageType.EXCEPTION:
2666 
      x = TApplicationException()
2667 
      x.read(self._iprot)
2668 
      self._iprot.readMessageEnd()
2669 
      raise x
2616 chandransh 2670 
    result = receiveReturn_result()
2591 chandransh 2671 
    result.read(self._iprot)
2672 
    self._iprot.readMessageEnd()
3431 rajveer 2673 
    if result.success is not None:
2591 chandransh 2674 
      return result.success
3431 rajveer 2675 
    if result.ex is not None:
2591 chandransh 2676 
      raise result.ex
2616 chandransh 2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2678 
 
2679 
  def validateDoa(self, orderId, isValid):
2680 
    """
4452 rajveer 2681 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2682 
    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 2683 
    If the order is in any other state, it returns false.
2684 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2685 
 
2591 chandransh 2686 
    Parameters:
2687 
     - orderId
2688 
     - isValid
2689 
    """
2690 
    self.send_validateDoa(orderId, isValid)
2691 
    return self.recv_validateDoa()
2692 
 
2693 
  def send_validateDoa(self, orderId, isValid):
2694 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2695 
    args = validateDoa_args()
2696 
    args.orderId = orderId
2697 
    args.isValid = isValid
2698 
    args.write(self._oprot)
2699 
    self._oprot.writeMessageEnd()
2700 
    self._oprot.trans.flush()
2701 
 
2702 
  def recv_validateDoa(self, ):
2703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2704 
    if mtype == TMessageType.EXCEPTION:
2705 
      x = TApplicationException()
2706 
      x.read(self._iprot)
2707 
      self._iprot.readMessageEnd()
2708 
      raise x
2709 
    result = validateDoa_result()
2710 
    result.read(self._iprot)
2711 
    self._iprot.readMessageEnd()
3431 rajveer 2712 
    if result.success is not None:
2591 chandransh 2713 
      return result.success
3431 rajveer 2714 
    if result.ex is not None:
2591 chandransh 2715 
      raise result.ex
2716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2717 
 
4495 rajveer 2718 
  def validateReturnProduct(self, orderId, isUsable):
2719 
    """
2720 
    Parameters:
2721 
     - orderId
2722 
     - isUsable
2723 
    """
2724 
    self.send_validateReturnProduct(orderId, isUsable)
2725 
    return self.recv_validateReturnProduct()
2726 
 
2727 
  def send_validateReturnProduct(self, orderId, isUsable):
2728 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2729 
    args = validateReturnProduct_args()
2730 
    args.orderId = orderId
2731 
    args.isUsable = isUsable
2732 
    args.write(self._oprot)
2733 
    self._oprot.writeMessageEnd()
2734 
    self._oprot.trans.flush()
2735 
 
2736 
  def recv_validateReturnProduct(self, ):
2737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2738 
    if mtype == TMessageType.EXCEPTION:
2739 
      x = TApplicationException()
2740 
      x.read(self._iprot)
2741 
      self._iprot.readMessageEnd()
2742 
      raise x
2743 
    result = validateReturnProduct_result()
2744 
    result.read(self._iprot)
2745 
    self._iprot.readMessageEnd()
2746 
    if result.success is not None:
2747 
      return result.success
2748 
    if result.ex is not None:
2749 
      raise result.ex
2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2751 
 
2616 chandransh 2752 
  def reshipOrder(self, orderId):
2753 
    """
4484 rajveer 2754 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2755 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2756 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 2757 
 
2758 
    If the order is in DOA_CERT_VALID state, it does the following:
2759 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2760 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2761 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2762 
 
2616 chandransh 2763 
    Returns the id of the newly created order.
3431 rajveer 2764 
 
2616 chandransh 2765 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2766 
 
2616 chandransh 2767 
    Parameters:
2768 
     - orderId
2769 
    """
2770 
    self.send_reshipOrder(orderId)
2771 
    return self.recv_reshipOrder()
2591 chandransh 2772 
 
2616 chandransh 2773 
  def send_reshipOrder(self, orderId):
2774 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2775 
    args = reshipOrder_args()
2776 
    args.orderId = orderId
2777 
    args.write(self._oprot)
2778 
    self._oprot.writeMessageEnd()
2779 
    self._oprot.trans.flush()
2780 
 
2781 
  def recv_reshipOrder(self, ):
2782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2783 
    if mtype == TMessageType.EXCEPTION:
2784 
      x = TApplicationException()
2785 
      x.read(self._iprot)
2786 
      self._iprot.readMessageEnd()
2787 
      raise x
2788 
    result = reshipOrder_result()
2789 
    result.read(self._iprot)
2790 
    self._iprot.readMessageEnd()
3431 rajveer 2791 
    if result.success is not None:
2616 chandransh 2792 
      return result.success
3431 rajveer 2793 
    if result.ex is not None:
2616 chandransh 2794 
      raise result.ex
2795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2796 
 
3226 chandransh 2797 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2798 
    """
4484 rajveer 2799 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2800 
    	1. Creates a refund request for batch processing.
2801 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2802 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2803 
 
2616 chandransh 2804 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2805 
    	1. Creates a refund request for batch processing.
3226 chandransh 2806 
    	2. Cancels the reservation of the item in the warehouse.
2807 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2808 
 
3226 chandransh 2809 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2810 
    	1. Cancels the reservation of the item in the warehouse.
2811 
    	2. Marks the current order as CANCELED.
2812 
 
2813 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2814 
 
2616 chandransh 2815 
    Returns True if it is successful, False otherwise.
3431 rajveer 2816 
 
2616 chandransh 2817 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2818 
 
2616 chandransh 2819 
    Parameters:
2820 
     - orderId
3226 chandransh 2821 
     - refundedBy
2822 
     - reason
2616 chandransh 2823 
    """
3226 chandransh 2824 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2825 
    return self.recv_refundOrder()
2826 
 
3226 chandransh 2827 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2828 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2829 
    args = refundOrder_args()
2830 
    args.orderId = orderId
3226 chandransh 2831 
    args.refundedBy = refundedBy
2832 
    args.reason = reason
2616 chandransh 2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
2837 
  def recv_refundOrder(self, ):
2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
2844 
    result = refundOrder_result()
2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
3431 rajveer 2847 
    if result.success is not None:
2616 chandransh 2848 
      return result.success
3431 rajveer 2849 
    if result.ex is not None:
2616 chandransh 2850 
      raise result.ex
2851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2852 
 
2690 chandransh 2853 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2854 
    """
2855 
    Get all return orders created between the from and to dates for the given warehouse.
2856 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2857 
 
2690 chandransh 2858 
    Parameters:
2859 
     - warehouseId
2860 
     - fromDate
2861 
     - toDate
2862 
    """
2863 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2864 
    return self.recv_getReturnOrders()
2616 chandransh 2865 
 
2690 chandransh 2866 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2867 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2868 
    args = getReturnOrders_args()
2869 
    args.warehouseId = warehouseId
2870 
    args.fromDate = fromDate
2871 
    args.toDate = toDate
2872 
    args.write(self._oprot)
2873 
    self._oprot.writeMessageEnd()
2874 
    self._oprot.trans.flush()
2875 
 
2876 
  def recv_getReturnOrders(self, ):
2877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2878 
    if mtype == TMessageType.EXCEPTION:
2879 
      x = TApplicationException()
2880 
      x.read(self._iprot)
2881 
      self._iprot.readMessageEnd()
2882 
      raise x
2883 
    result = getReturnOrders_result()
2884 
    result.read(self._iprot)
2885 
    self._iprot.readMessageEnd()
3431 rajveer 2886 
    if result.success is not None:
2690 chandransh 2887 
      return result.success
2888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2889 
 
2700 chandransh 2890 
  def getReturnOrder(self, id):
2891 
    """
2892 
    Returns the ReturnOrder corresponding to the given id.
2893 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2894 
 
2700 chandransh 2895 
    Parameters:
2896 
     - id
2897 
    """
2898 
    self.send_getReturnOrder(id)
2899 
    return self.recv_getReturnOrder()
2900 
 
2901 
  def send_getReturnOrder(self, id):
2902 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2903 
    args = getReturnOrder_args()
2904 
    args.id = id
2905 
    args.write(self._oprot)
2906 
    self._oprot.writeMessageEnd()
2907 
    self._oprot.trans.flush()
2908 
 
2909 
  def recv_getReturnOrder(self, ):
2910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2911 
    if mtype == TMessageType.EXCEPTION:
2912 
      x = TApplicationException()
2913 
      x.read(self._iprot)
2914 
      self._iprot.readMessageEnd()
2915 
      raise x
2916 
    result = getReturnOrder_result()
2917 
    result.read(self._iprot)
2918 
    self._iprot.readMessageEnd()
3431 rajveer 2919 
    if result.success is not None:
2700 chandransh 2920 
      return result.success
3431 rajveer 2921 
    if result.ex is not None:
2700 chandransh 2922 
      raise result.ex
2923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2924 
 
2690 chandransh 2925 
  def processReturn(self, returnOrderId):
2926 
    """
2927 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2928 
 
2690 chandransh 2929 
    Parameters:
2930 
     - returnOrderId
2931 
    """
2932 
    self.send_processReturn(returnOrderId)
2933 
    self.recv_processReturn()
2934 
 
2935 
  def send_processReturn(self, returnOrderId):
2936 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2937 
    args = processReturn_args()
2938 
    args.returnOrderId = returnOrderId
2939 
    args.write(self._oprot)
2940 
    self._oprot.writeMessageEnd()
2941 
    self._oprot.trans.flush()
2942 
 
2943 
  def recv_processReturn(self, ):
2944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2945 
    if mtype == TMessageType.EXCEPTION:
2946 
      x = TApplicationException()
2947 
      x.read(self._iprot)
2948 
      self._iprot.readMessageEnd()
2949 
      raise x
2950 
    result = processReturn_result()
2951 
    result.read(self._iprot)
2952 
    self._iprot.readMessageEnd()
3431 rajveer 2953 
    if result.ex is not None:
2690 chandransh 2954 
      raise result.ex
2955 
    return
2956 
 
2819 chandransh 2957 
  def createPurchaseOrder(self, warehouseId):
2958 
    """
2959 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2960 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2961 
 
2819 chandransh 2962 
    Parameters:
2963 
     - warehouseId
2964 
    """
2965 
    self.send_createPurchaseOrder(warehouseId)
2966 
    return self.recv_createPurchaseOrder()
2690 chandransh 2967 
 
2819 chandransh 2968 
  def send_createPurchaseOrder(self, warehouseId):
2969 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2970 
    args = createPurchaseOrder_args()
2971 
    args.warehouseId = warehouseId
2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
2976 
  def recv_createPurchaseOrder(self, ):
2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
2983 
    result = createPurchaseOrder_result()
2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
3431 rajveer 2986 
    if result.success is not None:
2819 chandransh 2987 
      return result.success
3431 rajveer 2988 
    if result.ex is not None:
2819 chandransh 2989 
      raise result.ex
2990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2991 
 
3451 chandransh 2992 
  def updateWeight(self, orderId, weight):
2993 
    """
2994 
    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 2995 
 
3451 chandransh 2996 
    Parameters:
2997 
     - orderId
2998 
     - weight
2999 
    """
3000 
    self.send_updateWeight(orderId, weight)
3001 
    return self.recv_updateWeight()
3002 
 
3003 
  def send_updateWeight(self, orderId, weight):
3004 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3005 
    args = updateWeight_args()
3006 
    args.orderId = orderId
3007 
    args.weight = weight
3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
3011 
 
3012 
  def recv_updateWeight(self, ):
3013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3014 
    if mtype == TMessageType.EXCEPTION:
3015 
      x = TApplicationException()
3016 
      x.read(self._iprot)
3017 
      self._iprot.readMessageEnd()
3018 
      raise x
3019 
    result = updateWeight_result()
3020 
    result.read(self._iprot)
3021 
    self._iprot.readMessageEnd()
3022 
    if result.success is not None:
3023 
      return result.success
3024 
    if result.ex is not None:
3025 
      raise result.ex
3026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3027 
 
3469 chandransh 3028 
  def changeItem(self, orderId, itemId):
3029 
    """
3030 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3031 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3032 
 
3469 chandransh 3033 
    Parameters:
3034 
     - orderId
3035 
     - itemId
3036 
    """
3037 
    self.send_changeItem(orderId, itemId)
3038 
    return self.recv_changeItem()
3039 
 
3040 
  def send_changeItem(self, orderId, itemId):
3041 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3042 
    args = changeItem_args()
3043 
    args.orderId = orderId
3044 
    args.itemId = itemId
3045 
    args.write(self._oprot)
3046 
    self._oprot.writeMessageEnd()
3047 
    self._oprot.trans.flush()
3048 
 
3049 
  def recv_changeItem(self, ):
3050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3051 
    if mtype == TMessageType.EXCEPTION:
3052 
      x = TApplicationException()
3053 
      x.read(self._iprot)
3054 
      self._iprot.readMessageEnd()
3055 
      raise x
3056 
    result = changeItem_result()
3057 
    result.read(self._iprot)
3058 
    self._iprot.readMessageEnd()
3059 
    if result.success is not None:
3060 
      return result.success
3061 
    if result.ex is not None:
3062 
      raise result.ex
3063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3064 
 
3065 
  def shiftToWarehouse(self, orderId, warehouseId):
3066 
    """
3067 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3068 
 
3069 
    Parameters:
3070 
     - orderId
3071 
     - warehouseId
3072 
    """
3073 
    self.send_shiftToWarehouse(orderId, warehouseId)
3074 
    return self.recv_shiftToWarehouse()
3075 
 
3076 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3077 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3078 
    args = shiftToWarehouse_args()
3079 
    args.orderId = orderId
3080 
    args.warehouseId = warehouseId
3081 
    args.write(self._oprot)
3082 
    self._oprot.writeMessageEnd()
3083 
    self._oprot.trans.flush()
3084 
 
3085 
  def recv_shiftToWarehouse(self, ):
3086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3087 
    if mtype == TMessageType.EXCEPTION:
3088 
      x = TApplicationException()
3089 
      x.read(self._iprot)
3090 
      self._iprot.readMessageEnd()
3091 
      raise x
3092 
    result = shiftToWarehouse_result()
3093 
    result.read(self._iprot)
3094 
    self._iprot.readMessageEnd()
3095 
    if result.success is not None:
3096 
      return result.success
3097 
    if result.ex is not None:
3098 
      raise result.ex
3099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3100 
 
3986 chandransh 3101 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3102 
    """
3103 
    Adds the given delay reason to the given order.
3986 chandransh 3104 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3105 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3106 
 
3553 chandransh 3107 
    Parameters:
3108 
     - orderId
3109 
     - delayReason
3986 chandransh 3110 
     - furtherDelay
3553 chandransh 3111 
    """
3986 chandransh 3112 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3113 
    return self.recv_addDelayReason()
3114 
 
3986 chandransh 3115 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3116 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3117 
    args = addDelayReason_args()
3118 
    args.orderId = orderId
3119 
    args.delayReason = delayReason
3986 chandransh 3120 
    args.furtherDelay = furtherDelay
3553 chandransh 3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_addDelayReason(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = addDelayReason_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3135 
    if result.success is not None:
3136 
      return result.success
3137 
    if result.ex is not None:
3138 
      raise result.ex
3139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3140 
 
3956 chandransh 3141 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3142 
    """
3143 
    Marks the COD orders with given AWB nos. as having been processed.
3144 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3145 
 
3956 chandransh 3146 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3147 
    1. There is no order corresponding to an AWB number.
3148 
    2. The captured amount for a payment exceeds the total payment.
3149 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3150 
 
3151 
    Parameters:
3152 
     - collectedAmountMap
3153 
     - xferBy
3154 
     - xferTxnId
3155 
     - xferDate
3156 
    """
3157 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3158 
    return self.recv_reconcileCodCollection()
3159 
 
3160 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3161 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3162 
    args = reconcileCodCollection_args()
3163 
    args.collectedAmountMap = collectedAmountMap
3164 
    args.xferBy = xferBy
3165 
    args.xferTxnId = xferTxnId
3166 
    args.xferDate = xferDate
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3171 
  def recv_reconcileCodCollection(self, ):
3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3178 
    result = reconcileCodCollection_result()
3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.success is not None:
3182 
      return result.success
3183 
    if result.ex is not None:
3184 
      raise result.ex
3185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3186 
 
4008 mandeep.dh 3187 
  def getTransactionsRequiringExtraProcessing(self, category):
3188 
    """
4065 mandeep.dh 3189 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3190 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3191 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3192 
 
4008 mandeep.dh 3193 
    Parameters:
3194 
     - category
3195 
    """
3196 
    self.send_getTransactionsRequiringExtraProcessing(category)
3197 
    return self.recv_getTransactionsRequiringExtraProcessing()
3198 
 
3199 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3200 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3201 
    args = getTransactionsRequiringExtraProcessing_args()
3202 
    args.category = category
3203 
    args.write(self._oprot)
3204 
    self._oprot.writeMessageEnd()
3205 
    self._oprot.trans.flush()
3206 
 
3207 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3209 
    if mtype == TMessageType.EXCEPTION:
3210 
      x = TApplicationException()
3211 
      x.read(self._iprot)
3212 
      self._iprot.readMessageEnd()
3213 
      raise x
3214 
    result = getTransactionsRequiringExtraProcessing_result()
3215 
    result.read(self._iprot)
3216 
    self._iprot.readMessageEnd()
3217 
    if result.success is not None:
3218 
      return result.success
3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3220 
 
3221 
  def markTransactionAsProcessed(self, transactionId, category):
3222 
    """
3223 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3224 
    It essentially deletes the transaction id record for a particular
3225 
    processing type category (if present) from DB.
3226 
    This is currently used by CRM application.
4008 mandeep.dh 3227 
 
3228 
    Parameters:
3229 
     - transactionId
3230 
     - category
3231 
    """
3232 
    self.send_markTransactionAsProcessed(transactionId, category)
3233 
    self.recv_markTransactionAsProcessed()
3234 
 
3235 
  def send_markTransactionAsProcessed(self, transactionId, category):
3236 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3237 
    args = markTransactionAsProcessed_args()
3238 
    args.transactionId = transactionId
3239 
    args.category = category
3240 
    args.write(self._oprot)
3241 
    self._oprot.writeMessageEnd()
3242 
    self._oprot.trans.flush()
3243 
 
3244 
  def recv_markTransactionAsProcessed(self, ):
3245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3246 
    if mtype == TMessageType.EXCEPTION:
3247 
      x = TApplicationException()
3248 
      x.read(self._iprot)
3249 
      self._iprot.readMessageEnd()
3250 
      raise x
3251 
    result = markTransactionAsProcessed_result()
3252 
    result.read(self._iprot)
3253 
    self._iprot.readMessageEnd()
3254 
    return
3255 
 
4018 chandransh 3256 
  def getItemWiseRiskyOrdersCount(self, ):
3257 
    """
3258 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3259 
    is defined as one whose shipping date is about to expire.
3260 
    """
3261 
    self.send_getItemWiseRiskyOrdersCount()
3262 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3263 
 
4018 chandransh 3264 
  def send_getItemWiseRiskyOrdersCount(self, ):
3265 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3266 
    args = getItemWiseRiskyOrdersCount_args()
3267 
    args.write(self._oprot)
3268 
    self._oprot.writeMessageEnd()
3269 
    self._oprot.trans.flush()
3270 
 
3271 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3273 
    if mtype == TMessageType.EXCEPTION:
3274 
      x = TApplicationException()
3275 
      x.read(self._iprot)
3276 
      self._iprot.readMessageEnd()
3277 
      raise x
3278 
    result = getItemWiseRiskyOrdersCount_result()
3279 
    result.read(self._iprot)
3280 
    self._iprot.readMessageEnd()
3281 
    if result.success is not None:
3282 
      return result.success
3283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3284 
 
4295 varun.gupt 3285 
  def getOrdersForItemIds(self, itemIds):
3286 
    """
3287 
    Returns a list of all orders which have items with given id
3288 
 
3289 
    Parameters:
3290 
     - itemIds
3291 
    """
3292 
    self.send_getOrdersForItemIds(itemIds)
3293 
    return self.recv_getOrdersForItemIds()
3294 
 
3295 
  def send_getOrdersForItemIds(self, itemIds):
3296 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3297 
    args = getOrdersForItemIds_args()
3298 
    args.itemIds = itemIds
3299 
    args.write(self._oprot)
3300 
    self._oprot.writeMessageEnd()
3301 
    self._oprot.trans.flush()
3302 
 
3303 
  def recv_getOrdersForItemIds(self, ):
3304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3305 
    if mtype == TMessageType.EXCEPTION:
3306 
      x = TApplicationException()
3307 
      x.read(self._iprot)
3308 
      self._iprot.readMessageEnd()
3309 
      raise x
3310 
    result = getOrdersForItemIds_result()
3311 
    result.read(self._iprot)
3312 
    self._iprot.readMessageEnd()
3313 
    if result.success is not None:
3314 
      return result.success
3315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3316 
 
4247 rajveer 3317 
  def markOrderCancellationRequestReceived(self, orderId):
3318 
    """
3319 
    Mark order as cancellation request received. If customer sends request of cancellation of
3320 
    a particular order, this method will be called. It will just change status of the order
3321 
    depending on its current status. It also records the previous status, so that we can move
3322 
    back to that status if cancellation request is denied.
4018 chandransh 3323 
 
4247 rajveer 3324 
    Parameters:
3325 
     - orderId
3326 
    """
3327 
    self.send_markOrderCancellationRequestReceived(orderId)
3328 
    self.recv_markOrderCancellationRequestReceived()
3329 
 
3330 
  def send_markOrderCancellationRequestReceived(self, orderId):
3331 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3332 
    args = markOrderCancellationRequestReceived_args()
3333 
    args.orderId = orderId
3334 
    args.write(self._oprot)
3335 
    self._oprot.writeMessageEnd()
3336 
    self._oprot.trans.flush()
3337 
 
3338 
  def recv_markOrderCancellationRequestReceived(self, ):
3339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3340 
    if mtype == TMessageType.EXCEPTION:
3341 
      x = TApplicationException()
3342 
      x.read(self._iprot)
3343 
      self._iprot.readMessageEnd()
3344 
      raise x
3345 
    result = markOrderCancellationRequestReceived_result()
3346 
    result.read(self._iprot)
3347 
    self._iprot.readMessageEnd()
3348 
    if result.ex is not None:
3349 
      raise result.ex
3350 
    return
3351 
 
3352 
  def markOrderCancellationRequestConfirmed(self, orderId):
3353 
    """
3354 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3355 
    cancellation request confirmed. After this OM will be able to cancel the order.
3356 
 
3357 
    Parameters:
3358 
     - orderId
3359 
    """
3360 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3361 
    self.recv_markOrderCancellationRequestConfirmed()
3362 
 
3363 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3364 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3365 
    args = markOrderCancellationRequestConfirmed_args()
3366 
    args.orderId = orderId
3367 
    args.write(self._oprot)
3368 
    self._oprot.writeMessageEnd()
3369 
    self._oprot.trans.flush()
3370 
 
3371 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3373 
    if mtype == TMessageType.EXCEPTION:
3374 
      x = TApplicationException()
3375 
      x.read(self._iprot)
3376 
      self._iprot.readMessageEnd()
3377 
      raise x
3378 
    result = markOrderCancellationRequestConfirmed_result()
3379 
    result.read(self._iprot)
3380 
    self._iprot.readMessageEnd()
3381 
    if result.ex is not None:
3382 
      raise result.ex
3383 
    return
3384 
 
3385 
  def markOrderCancellationRequestDenied(self, orderId):
3386 
    """
3387 
    If we decide to not to cancel order, we will move the order ro previous status.
3388 
 
3389 
    Parameters:
3390 
     - orderId
3391 
    """
3392 
    self.send_markOrderCancellationRequestDenied(orderId)
3393 
    self.recv_markOrderCancellationRequestDenied()
3394 
 
3395 
  def send_markOrderCancellationRequestDenied(self, orderId):
3396 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3397 
    args = markOrderCancellationRequestDenied_args()
3398 
    args.orderId = orderId
3399 
    args.write(self._oprot)
3400 
    self._oprot.writeMessageEnd()
3401 
    self._oprot.trans.flush()
3402 
 
3403 
  def recv_markOrderCancellationRequestDenied(self, ):
3404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3405 
    if mtype == TMessageType.EXCEPTION:
3406 
      x = TApplicationException()
3407 
      x.read(self._iprot)
3408 
      self._iprot.readMessageEnd()
3409 
      raise x
3410 
    result = markOrderCancellationRequestDenied_result()
3411 
    result.read(self._iprot)
3412 
    self._iprot.readMessageEnd()
3413 
    if result.ex is not None:
3414 
      raise result.ex
3415 
    return
3416 
 
4258 rajveer 3417 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3418 
    """
4258 rajveer 3419 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3420 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3421 
 
3422 
    Parameters:
4258 rajveer 3423 
     - transactionId
4247 rajveer 3424 
    """
4258 rajveer 3425 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3426 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3427 
 
4258 rajveer 3428 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3429 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3430 
    args = markTransactionAsPaymentFlagRemoved_args()
3431 
    args.transactionId = transactionId
4247 rajveer 3432 
    args.write(self._oprot)
3433 
    self._oprot.writeMessageEnd()
3434 
    self._oprot.trans.flush()
3435 
 
4258 rajveer 3436 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3438 
    if mtype == TMessageType.EXCEPTION:
3439 
      x = TApplicationException()
3440 
      x.read(self._iprot)
3441 
      self._iprot.readMessageEnd()
3442 
      raise x
4258 rajveer 3443 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3444 
    result.read(self._iprot)
3445 
    self._iprot.readMessageEnd()
3446 
    if result.ex is not None:
3447 
      raise result.ex
3448 
    return
3449 
 
4259 anupam.sin 3450 
  def refundTransaction(self, transactionId, refundedBy, reason):
3451 
    """
3452 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3453 
    need to be cancelled
4247 rajveer 3454 
 
4259 anupam.sin 3455 
    Parameters:
3456 
     - transactionId
3457 
     - refundedBy
3458 
     - reason
3459 
    """
3460 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3461 
    self.recv_refundTransaction()
3462 
 
3463 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3464 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3465 
    args = refundTransaction_args()
3466 
    args.transactionId = transactionId
3467 
    args.refundedBy = refundedBy
3468 
    args.reason = reason
3469 
    args.write(self._oprot)
3470 
    self._oprot.writeMessageEnd()
3471 
    self._oprot.trans.flush()
3472 
 
3473 
  def recv_refundTransaction(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 = refundTransaction_result()
3481 
    result.read(self._iprot)
3482 
    self._iprot.readMessageEnd()
3483 
    if result.ex is not None:
3484 
      raise result.ex
3485 
    return
3486 
 
4324 mandeep.dh 3487 
  def updateShipmentAddress(self, orderId, addressId):
3488 
    """
3489 
    Updates shipment address of an order. Delivery and shipping date estimates
3490 
    etc. are also updated here.
3491 
 
3492 
    Throws TransactionServiceException in case address change is not
3493 
    possible due to certain reasons such as new pincode in address is
3494 
    not serviceable etc.
3495 
 
3496 
    Parameters:
3497 
     - orderId
3498 
     - addressId
3499 
    """
3500 
    self.send_updateShipmentAddress(orderId, addressId)
3501 
    self.recv_updateShipmentAddress()
3502 
 
3503 
  def send_updateShipmentAddress(self, orderId, addressId):
3504 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3505 
    args = updateShipmentAddress_args()
3506 
    args.orderId = orderId
3507 
    args.addressId = addressId
3508 
    args.write(self._oprot)
3509 
    self._oprot.writeMessageEnd()
3510 
    self._oprot.trans.flush()
3511 
 
3512 
  def recv_updateShipmentAddress(self, ):
3513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3514 
    if mtype == TMessageType.EXCEPTION:
3515 
      x = TApplicationException()
3516 
      x.read(self._iprot)
3517 
      self._iprot.readMessageEnd()
3518 
      raise x
3519 
    result = updateShipmentAddress_result()
3520 
    result.read(self._iprot)
3521 
    self._iprot.readMessageEnd()
3522 
    if result.ex is not None:
3523 
      raise result.ex
3524 
    return
3525 
 
4285 rajveer 3526 
  def acceptOrdersForItemId(self, itemId, inventory):
3527 
    """
3528 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3529 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3530 
 
4285 rajveer 3531 
    Parameters:
3532 
     - itemId
3533 
     - inventory
3534 
    """
3535 
    self.send_acceptOrdersForItemId(itemId, inventory)
3536 
    return self.recv_acceptOrdersForItemId()
3537 
 
3538 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3539 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3540 
    args = acceptOrdersForItemId_args()
3541 
    args.itemId = itemId
3542 
    args.inventory = inventory
3543 
    args.write(self._oprot)
3544 
    self._oprot.writeMessageEnd()
3545 
    self._oprot.trans.flush()
3546 
 
3547 
  def recv_acceptOrdersForItemId(self, ):
3548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3549 
    if mtype == TMessageType.EXCEPTION:
3550 
      x = TApplicationException()
3551 
      x.read(self._iprot)
3552 
      self._iprot.readMessageEnd()
3553 
      raise x
3554 
    result = acceptOrdersForItemId_result()
3555 
    result.read(self._iprot)
3556 
    self._iprot.readMessageEnd()
3557 
    if result.success is not None:
3558 
      return result.success
3559 
    if result.ex is not None:
3560 
      raise result.ex
3561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3562 
 
4369 rajveer 3563 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3564 
    """
3565 
    Parameters:
3566 
     - vendorId
3567 
     - itemId
3568 
     - quantity
3569 
     - estimate
4369 rajveer 3570 
     - isReminder
4303 rajveer 3571 
    """
4369 rajveer 3572 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3573 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3574 
 
4369 rajveer 3575 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3576 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3577 
    args = markOrdersAsPORaised_args()
3578 
    args.vendorId = vendorId
3579 
    args.itemId = itemId
3580 
    args.quantity = quantity
3581 
    args.estimate = estimate
4369 rajveer 3582 
    args.isReminder = isReminder
4303 rajveer 3583 
    args.write(self._oprot)
3584 
    self._oprot.writeMessageEnd()
3585 
    self._oprot.trans.flush()
3586 
 
3587 
  def recv_markOrdersAsPORaised(self, ):
3588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3589 
    if mtype == TMessageType.EXCEPTION:
3590 
      x = TApplicationException()
3591 
      x.read(self._iprot)
3592 
      self._iprot.readMessageEnd()
3593 
      raise x
3594 
    result = markOrdersAsPORaised_result()
3595 
    result.read(self._iprot)
3596 
    self._iprot.readMessageEnd()
3597 
    if result.ex is not None:
3598 
      raise result.ex
3599 
    return
3600 
 
4369 rajveer 3601 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3602 
    """
3603 
    Parameters:
3604 
     - vendorId
3605 
     - itemId
3606 
     - quantity
3607 
     - estimate
4369 rajveer 3608 
     - isReminder
4303 rajveer 3609 
    """
4369 rajveer 3610 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3611 
    self.recv_markOrdersAsReversalInitiated()
3612 
 
4369 rajveer 3613 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3614 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3615 
    args = markOrdersAsReversalInitiated_args()
3616 
    args.vendorId = vendorId
3617 
    args.itemId = itemId
3618 
    args.quantity = quantity
3619 
    args.estimate = estimate
4369 rajveer 3620 
    args.isReminder = isReminder
4303 rajveer 3621 
    args.write(self._oprot)
3622 
    self._oprot.writeMessageEnd()
3623 
    self._oprot.trans.flush()
3624 
 
3625 
  def recv_markOrdersAsReversalInitiated(self, ):
3626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3627 
    if mtype == TMessageType.EXCEPTION:
3628 
      x = TApplicationException()
3629 
      x.read(self._iprot)
3630 
      self._iprot.readMessageEnd()
3631 
      raise x
3632 
    result = markOrdersAsReversalInitiated_result()
3633 
    result.read(self._iprot)
3634 
    self._iprot.readMessageEnd()
3635 
    if result.ex is not None:
3636 
      raise result.ex
3637 
    return
3638 
 
4369 rajveer 3639 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3640 
    """
3641 
    Parameters:
3642 
     - vendorId
3643 
     - itemId
3644 
     - quantity
3645 
     - estimate
4369 rajveer 3646 
     - isReminder
4303 rajveer 3647 
    """
4369 rajveer 3648 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3649 
    self.recv_markOrdersAsNotAvailabke()
3650 
 
4369 rajveer 3651 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3652 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3653 
    args = markOrdersAsNotAvailabke_args()
3654 
    args.vendorId = vendorId
3655 
    args.itemId = itemId
3656 
    args.quantity = quantity
3657 
    args.estimate = estimate
4369 rajveer 3658 
    args.isReminder = isReminder
4303 rajveer 3659 
    args.write(self._oprot)
3660 
    self._oprot.writeMessageEnd()
3661 
    self._oprot.trans.flush()
3662 
 
3663 
  def recv_markOrdersAsNotAvailabke(self, ):
3664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3665 
    if mtype == TMessageType.EXCEPTION:
3666 
      x = TApplicationException()
3667 
      x.read(self._iprot)
3668 
      self._iprot.readMessageEnd()
3669 
      raise x
3670 
    result = markOrdersAsNotAvailabke_result()
3671 
    result.read(self._iprot)
3672 
    self._iprot.readMessageEnd()
3673 
    if result.ex is not None:
3674 
      raise result.ex
3675 
    return
3676 
 
4369 rajveer 3677 
  def markOrdersAsTimeout(self, vendorId):
3678 
    """
3679 
    Parameters:
3680 
     - vendorId
3681 
    """
3682 
    self.send_markOrdersAsTimeout(vendorId)
3683 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3684 
 
4369 rajveer 3685 
  def send_markOrdersAsTimeout(self, vendorId):
3686 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3687 
    args = markOrdersAsTimeout_args()
3688 
    args.vendorId = vendorId
3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
3693 
  def recv_markOrdersAsTimeout(self, ):
3694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3695 
    if mtype == TMessageType.EXCEPTION:
3696 
      x = TApplicationException()
3697 
      x.read(self._iprot)
3698 
      self._iprot.readMessageEnd()
3699 
      raise x
3700 
    result = markOrdersAsTimeout_result()
3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3703 
    if result.success is not None:
3704 
      return result.success
3705 
    if result.ex is not None:
3706 
      raise result.ex
3707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3708 
 
4386 anupam.sin 3709 
  def getOrderForAwb(self, awb):
3710 
    """
3711 
    Returns the order corresponding to an AWB number
4369 rajveer 3712 
 
4386 anupam.sin 3713 
    Parameters:
3714 
     - awb
3715 
    """
3716 
    self.send_getOrderForAwb(awb)
3717 
    return self.recv_getOrderForAwb()
3718 
 
3719 
  def send_getOrderForAwb(self, awb):
3720 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3721 
    args = getOrderForAwb_args()
3722 
    args.awb = awb
3723 
    args.write(self._oprot)
3724 
    self._oprot.writeMessageEnd()
3725 
    self._oprot.trans.flush()
3726 
 
3727 
  def recv_getOrderForAwb(self, ):
3728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3729 
    if mtype == TMessageType.EXCEPTION:
3730 
      x = TApplicationException()
3731 
      x.read(self._iprot)
3732 
      self._iprot.readMessageEnd()
3733 
      raise x
3734 
    result = getOrderForAwb_result()
3735 
    result.read(self._iprot)
3736 
    self._iprot.readMessageEnd()
3737 
    if result.success is not None:
3738 
      return result.success
3739 
    if result.ex is not None:
3740 
      raise result.ex
3741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3742 
 
4506 phani.kuma 3743 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3744 
    """
3745 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3746 
 
4506 phani.kuma 3747 
    Parameters:
3748 
     - logistics_provider_id
3749 
     - order_status
3750 
    """
3751 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3752 
    return self.recv_getOrdersForProviderForStatus()
3753 
 
3754 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3755 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3756 
    args = getOrdersForProviderForStatus_args()
3757 
    args.logistics_provider_id = logistics_provider_id
3758 
    args.order_status = order_status
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_getOrdersForProviderForStatus(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = getOrdersForProviderForStatus_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    if result.ex is not None:
3776 
      raise result.ex
3777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3778 
 
3779 
 
3376 rajveer 3780 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3781 
  def __init__(self, handler):
3376 rajveer 3782 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3783 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3784 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3785 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3786 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3787 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3788 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3789 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3790 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3791 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3792 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3793 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3794 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3795 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3796 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3797 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3798 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3799 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3800 
    self._processMap["createOrder"] = Processor.process_createOrder
3801 
    self._processMap["getOrder"] = Processor.process_getOrder
3802 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3803 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3804 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3805 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3806 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3807 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3808 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3809 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3810 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3811 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3812 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3813 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3814 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3815 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 3816 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 3817 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3818 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3819 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3820 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3821 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3822 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3823 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3824 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3825 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3826 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 3827 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
3828 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 3829 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3830 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3831 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3832 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3833 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 3834 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 3835 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3836 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3837 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3838 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3839 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3840 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3841 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3842 
    self._processMap["changeItem"] = Processor.process_changeItem
3843 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3844 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3845 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3846 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3847 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3848 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3849 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3850 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3851 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3852 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3853 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3854 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3855 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3856 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3857 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3858 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3859 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3860 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3861 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 3862 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
94 ashish 3863 
 
3864 
  def process(self, iprot, oprot):
3865 
    (name, type, seqid) = iprot.readMessageBegin()
3866 
    if name not in self._processMap:
3867 
      iprot.skip(TType.STRUCT)
3868 
      iprot.readMessageEnd()
3869 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3870 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3871 
      x.write(oprot)
3872 
      oprot.writeMessageEnd()
3873 
      oprot.trans.flush()
3874 
      return
3875 
    else:
3876 
      self._processMap[name](self, seqid, iprot, oprot)
3877 
    return True
3878 
 
3879 
  def process_createTransaction(self, seqid, iprot, oprot):
3880 
    args = createTransaction_args()
3881 
    args.read(iprot)
3882 
    iprot.readMessageEnd()
3883 
    result = createTransaction_result()
3884 
    try:
132 ashish 3885 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3886 
    except TransactionServiceException, ex:
3887 
      result.ex = ex
3888 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3889 
    result.write(oprot)
3890 
    oprot.writeMessageEnd()
3891 
    oprot.trans.flush()
3892 
 
3893 
  def process_getTransaction(self, seqid, iprot, oprot):
3894 
    args = getTransaction_args()
3895 
    args.read(iprot)
3896 
    iprot.readMessageEnd()
3897 
    result = getTransaction_result()
3898 
    try:
3899 
      result.success = self._handler.getTransaction(args.id)
3900 
    except TransactionServiceException, ex:
3901 
      result.ex = ex
3902 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3903 
    result.write(oprot)
3904 
    oprot.writeMessageEnd()
3905 
    oprot.trans.flush()
3906 
 
3907 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3908 
    args = getTransactionsForCustomer_args()
3909 
    args.read(iprot)
3910 
    iprot.readMessageEnd()
3911 
    result = getTransactionsForCustomer_result()
3912 
    try:
3913 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3914 
    except TransactionServiceException, ex:
3915 
      result.ex = ex
3916 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3917 
    result.write(oprot)
3918 
    oprot.writeMessageEnd()
3919 
    oprot.trans.flush()
3920 
 
132 ashish 3921 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3922 
    args = getTransactionsForShoppingCartId_args()
3923 
    args.read(iprot)
3924 
    iprot.readMessageEnd()
3925 
    result = getTransactionsForShoppingCartId_result()
3926 
    try:
3927 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3928 
    except TransactionServiceException, ex:
3929 
      result.ex = ex
3930 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3931 
    result.write(oprot)
3932 
    oprot.writeMessageEnd()
3933 
    oprot.trans.flush()
3934 
 
94 ashish 3935 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3936 
    args = getTransactionStatus_args()
3937 
    args.read(iprot)
3938 
    iprot.readMessageEnd()
3939 
    result = getTransactionStatus_result()
3940 
    try:
3941 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3942 
    except TransactionServiceException, ex:
3943 
      result.ex = ex
3944 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3945 
    result.write(oprot)
3946 
    oprot.writeMessageEnd()
3947 
    oprot.trans.flush()
3948 
 
3949 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3950 
    args = changeTransactionStatus_args()
3951 
    args.read(iprot)
3952 
    iprot.readMessageEnd()
3953 
    result = changeTransactionStatus_result()
3954 
    try:
3955 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3956 
    except TransactionServiceException, ex:
3957 
      result.ex = ex
3958 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3959 
    result.write(oprot)
3960 
    oprot.writeMessageEnd()
3961 
    oprot.trans.flush()
3962 
 
1398 varun.gupt 3963 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3964 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3965 
    args.read(iprot)
3966 
    iprot.readMessageEnd()
1398 varun.gupt 3967 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3968 
    try:
1398 varun.gupt 3969 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3970 
    except TransactionServiceException, ex:
3971 
      result.ex = ex
1398 varun.gupt 3972 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3973 
    result.write(oprot)
3974 
    oprot.writeMessageEnd()
3975 
    oprot.trans.flush()
3976 
 
483 rajveer 3977 
  def process_getAllOrders(self, seqid, iprot, oprot):
3978 
    args = getAllOrders_args()
94 ashish 3979 
    args.read(iprot)
3980 
    iprot.readMessageEnd()
483 rajveer 3981 
    result = getAllOrders_result()
94 ashish 3982 
    try:
483 rajveer 3983 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3984 
    except TransactionServiceException, ex:
3985 
      result.ex = ex
483 rajveer 3986 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3987 
    result.write(oprot)
3988 
    oprot.writeMessageEnd()
3989 
    oprot.trans.flush()
3990 
 
4133 chandransh 3991 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3992 
    args = getOrdersInBatch_args()
3993 
    args.read(iprot)
3994 
    iprot.readMessageEnd()
3995 
    result = getOrdersInBatch_result()
3996 
    try:
3997 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3998 
    except TransactionServiceException, ex:
3999 
      result.ex = ex
4000 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4001 
    result.write(oprot)
4002 
    oprot.writeMessageEnd()
4003 
    oprot.trans.flush()
4004 
 
4005 
  def process_getOrderCount(self, seqid, iprot, oprot):
4006 
    args = getOrderCount_args()
4007 
    args.read(iprot)
4008 
    iprot.readMessageEnd()
4009 
    result = getOrderCount_result()
4010 
    try:
4011 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4012 
    except TransactionServiceException, ex:
4013 
      result.ex = ex
4014 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4015 
    result.write(oprot)
4016 
    oprot.writeMessageEnd()
4017 
    oprot.trans.flush()
4018 
 
999 varun.gupt 4019 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4020 
    args = getOrdersByBillingDate_args()
4021 
    args.read(iprot)
4022 
    iprot.readMessageEnd()
4023 
    result = getOrdersByBillingDate_result()
4024 
    try:
4025 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4026 
    except TransactionServiceException, ex:
4027 
      result.ex = ex
4028 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4029 
    result.write(oprot)
4030 
    oprot.writeMessageEnd()
4031 
    oprot.trans.flush()
4032 
 
3427 chandransh 4033 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4034 
    args = getOrdersByShippingDate_args()
4035 
    args.read(iprot)
4036 
    iprot.readMessageEnd()
4037 
    result = getOrdersByShippingDate_result()
4038 
    try:
3451 chandransh 4039 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4040 
    except TransactionServiceException, ex:
4041 
      result.ex = ex
4042 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4043 
    result.write(oprot)
4044 
    oprot.writeMessageEnd()
4045 
    oprot.trans.flush()
4046 
 
1382 varun.gupt 4047 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4048 
    args = getReturnableOrdersForCustomer_args()
4049 
    args.read(iprot)
4050 
    iprot.readMessageEnd()
4051 
    result = getReturnableOrdersForCustomer_result()
4052 
    try:
4053 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4054 
    except TransactionServiceException, ex:
4055 
      result.ex = ex
4056 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4057 
    result.write(oprot)
4058 
    oprot.writeMessageEnd()
4059 
    oprot.trans.flush()
4060 
 
4061 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4062 
    args = getCancellableOrdersForCustomer_args()
4063 
    args.read(iprot)
4064 
    iprot.readMessageEnd()
4065 
    result = getCancellableOrdersForCustomer_result()
4066 
    try:
4067 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4068 
    except TransactionServiceException, ex:
4069 
      result.ex = ex
4070 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4071 
    result.write(oprot)
4072 
    oprot.writeMessageEnd()
4073 
    oprot.trans.flush()
4074 
 
483 rajveer 4075 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4076 
    args = changeOrderStatus_args()
94 ashish 4077 
    args.read(iprot)
4078 
    iprot.readMessageEnd()
483 rajveer 4079 
    result = changeOrderStatus_result()
94 ashish 4080 
    try:
483 rajveer 4081 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4082 
    except TransactionServiceException, ex:
4083 
      result.ex = ex
483 rajveer 4084 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4088 
 
483 rajveer 4089 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4090 
    args = getOrdersForTransaction_args()
94 ashish 4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
483 rajveer 4093 
    result = getOrdersForTransaction_result()
94 ashish 4094 
    try:
1528 ankur.sing 4095 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4096 
    except TransactionServiceException, ex:
4097 
      result.ex = ex
483 rajveer 4098 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4099 
    result.write(oprot)
4100 
    oprot.writeMessageEnd()
4101 
    oprot.trans.flush()
4102 
 
483 rajveer 4103 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4104 
    args = getOrdersForCustomer_args()
94 ashish 4105 
    args.read(iprot)
4106 
    iprot.readMessageEnd()
483 rajveer 4107 
    result = getOrdersForCustomer_result()
94 ashish 4108 
    try:
3014 chandransh 4109 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4110 
    except TransactionServiceException, ex:
4111 
      result.ex = ex
483 rajveer 4112 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4113 
    result.write(oprot)
4114 
    oprot.writeMessageEnd()
4115 
    oprot.trans.flush()
4116 
 
483 rajveer 4117 
  def process_createOrder(self, seqid, iprot, oprot):
4118 
    args = createOrder_args()
94 ashish 4119 
    args.read(iprot)
4120 
    iprot.readMessageEnd()
483 rajveer 4121 
    result = createOrder_result()
94 ashish 4122 
    try:
483 rajveer 4123 
      result.success = self._handler.createOrder(args.order)
94 ashish 4124 
    except TransactionServiceException, ex:
4125 
      result.ex = ex
483 rajveer 4126 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4127 
    result.write(oprot)
4128 
    oprot.writeMessageEnd()
4129 
    oprot.trans.flush()
4130 
 
483 rajveer 4131 
  def process_getOrder(self, seqid, iprot, oprot):
4132 
    args = getOrder_args()
94 ashish 4133 
    args.read(iprot)
4134 
    iprot.readMessageEnd()
483 rajveer 4135 
    result = getOrder_result()
94 ashish 4136 
    try:
483 rajveer 4137 
      result.success = self._handler.getOrder(args.id)
94 ashish 4138 
    except TransactionServiceException, ex:
4139 
      result.ex = ex
483 rajveer 4140 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4141 
    result.write(oprot)
4142 
    oprot.writeMessageEnd()
4143 
    oprot.trans.flush()
4144 
 
483 rajveer 4145 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4146 
    args = getLineItemsForOrder_args()
94 ashish 4147 
    args.read(iprot)
4148 
    iprot.readMessageEnd()
483 rajveer 4149 
    result = getLineItemsForOrder_result()
94 ashish 4150 
    try:
483 rajveer 4151 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4152 
    except TransactionServiceException, ex:
4153 
      result.ex = ex
483 rajveer 4154 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4155 
    result.write(oprot)
4156 
    oprot.writeMessageEnd()
4157 
    oprot.trans.flush()
4158 
 
1528 ankur.sing 4159 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4160 
    args = getOrderForCustomer_args()
4161 
    args.read(iprot)
4162 
    iprot.readMessageEnd()
4163 
    result = getOrderForCustomer_result()
4164 
    try:
4165 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4166 
    except TransactionServiceException, ex:
4167 
      result.ex = ex
4168 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4169 
    result.write(oprot)
4170 
    oprot.writeMessageEnd()
4171 
    oprot.trans.flush()
4172 
 
3064 chandransh 4173 
  def process_getAlerts(self, seqid, iprot, oprot):
4174 
    args = getAlerts_args()
4175 
    args.read(iprot)
4176 
    iprot.readMessageEnd()
4177 
    result = getAlerts_result()
4444 rajveer 4178 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4179 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4180 
    result.write(oprot)
4181 
    oprot.writeMessageEnd()
4182 
    oprot.trans.flush()
4183 
 
4394 rajveer 4184 
  def process_addAlert(self, seqid, iprot, oprot):
4185 
    args = addAlert_args()
3064 chandransh 4186 
    args.read(iprot)
4187 
    iprot.readMessageEnd()
4394 rajveer 4188 
    result = addAlert_result()
4444 rajveer 4189 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4190 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4191 
    result.write(oprot)
4192 
    oprot.writeMessageEnd()
4193 
    oprot.trans.flush()
4194 
 
4444 rajveer 4195 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4196 
    args = markAlertsAsSeen_args()
4197 
    args.read(iprot)
4198 
    iprot.readMessageEnd()
4199 
    result = markAlertsAsSeen_result()
4200 
    self._handler.markAlertsAsSeen(args.warehouseId)
4201 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4202 
    result.write(oprot)
4203 
    oprot.writeMessageEnd()
4204 
    oprot.trans.flush()
4205 
 
3064 chandransh 4206 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4207 
    args = getValidOrderCount_args()
4208 
    args.read(iprot)
4209 
    iprot.readMessageEnd()
4210 
    result = getValidOrderCount_result()
4211 
    result.success = self._handler.getValidOrderCount()
4212 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4213 
    result.write(oprot)
4214 
    oprot.writeMessageEnd()
4215 
    oprot.trans.flush()
4216 
 
4217 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4218 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4219 
    args.read(iprot)
4220 
    iprot.readMessageEnd()
4221 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4222 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4223 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4224 
    result.write(oprot)
4225 
    oprot.writeMessageEnd()
4226 
    oprot.trans.flush()
4227 
 
4228 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4229 
    args = getValidOrdersAmountRange_args()
4230 
    args.read(iprot)
4231 
    iprot.readMessageEnd()
4232 
    result = getValidOrdersAmountRange_result()
4233 
    result.success = self._handler.getValidOrdersAmountRange()
4234 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4239 
  def process_getValidOrders(self, seqid, iprot, oprot):
4240 
    args = getValidOrders_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getValidOrders_result()
4244 
    result.success = self._handler.getValidOrders(args.limit)
4245 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4246 
    result.write(oprot)
4247 
    oprot.writeMessageEnd()
4248 
    oprot.trans.flush()
4249 
 
1220 chandransh 4250 
  def process_batchOrders(self, seqid, iprot, oprot):
4251 
    args = batchOrders_args()
4252 
    args.read(iprot)
4253 
    iprot.readMessageEnd()
4254 
    result = batchOrders_result()
4255 
    try:
4256 
      result.success = self._handler.batchOrders(args.warehouseId)
4257 
    except TransactionServiceException, ex:
4258 
      result.ex = ex
4259 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4260 
    result.write(oprot)
4261 
    oprot.writeMessageEnd()
4262 
    oprot.trans.flush()
4263 
 
1208 chandransh 4264 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4265 
    args = markOrderAsOutOfStock_args()
4266 
    args.read(iprot)
4267 
    iprot.readMessageEnd()
4268 
    result = markOrderAsOutOfStock_result()
4269 
    try:
4270 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4271 
    except TransactionServiceException, ex:
4272 
      result.ex = ex
4273 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
4277 
 
3064 chandransh 4278 
  def process_verifyOrder(self, seqid, iprot, oprot):
4279 
    args = verifyOrder_args()
759 chandransh 4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
3064 chandransh 4282 
    result = verifyOrder_result()
759 chandransh 4283 
    try:
3064 chandransh 4284 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4285 
    except TransactionServiceException, ex:
4286 
      result.ex = ex
3064 chandransh 4287 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4288 
    result.write(oprot)
4289 
    oprot.writeMessageEnd()
4290 
    oprot.trans.flush()
4291 
 
3064 chandransh 4292 
  def process_acceptOrder(self, seqid, iprot, oprot):
4293 
    args = acceptOrder_args()
1113 chandransh 4294 
    args.read(iprot)
4295 
    iprot.readMessageEnd()
3064 chandransh 4296 
    result = acceptOrder_result()
1113 chandransh 4297 
    try:
3064 chandransh 4298 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4299 
    except TransactionServiceException, ex:
4300 
      result.ex = ex
3064 chandransh 4301 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4302 
    result.write(oprot)
4303 
    oprot.writeMessageEnd()
4304 
    oprot.trans.flush()
4305 
 
3064 chandransh 4306 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4307 
    args = addBillingDetails_args()
1135 chandransh 4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
3064 chandransh 4310 
    result = addBillingDetails_result()
1135 chandransh 4311 
    try:
4283 anupam.sin 4312 
      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 4313 
    except TransactionServiceException, ex:
4314 
      result.ex = ex
3064 chandransh 4315 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
4319 
 
4579 rajveer 4320 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4321 
    args = addInvoiceNumber_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = addInvoiceNumber_result()
4325 
    try:
4326 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4327 
    except TransactionServiceException, ex:
4328 
      result.ex = ex
4329 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4330 
    result.write(oprot)
4331 
    oprot.writeMessageEnd()
4332 
    oprot.trans.flush()
4333 
 
3064 chandransh 4334 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4335 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4336 
    args.read(iprot)
4337 
    iprot.readMessageEnd()
3064 chandransh 4338 
    result = markOrdersAsManifested_result()
4339 
    try:
4340 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4341 
    except TransactionServiceException, ex:
4342 
      result.ex = ex
4343 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4344 
    result.write(oprot)
4345 
    oprot.writeMessageEnd()
4346 
    oprot.trans.flush()
4347 
 
4410 rajveer 4348 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4349 
    args = markOrdersAsShippedFromWarehouse_args()
4350 
    args.read(iprot)
4351 
    iprot.readMessageEnd()
4352 
    result = markOrdersAsShippedFromWarehouse_result()
4353 
    try:
4354 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4355 
    except TransactionServiceException, ex:
4356 
      result.ex = ex
4357 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4358 
    result.write(oprot)
4359 
    oprot.writeMessageEnd()
4360 
    oprot.trans.flush()
4361 
 
3064 chandransh 4362 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4363 
    args = markOrdersAsPickedUp_args()
304 ashish 4364 
    args.read(iprot)
4365 
    iprot.readMessageEnd()
3064 chandransh 4366 
    result = markOrdersAsPickedUp_result()
4367 
    try:
4368 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4369 
    except TransactionServiceException, ex:
4370 
      result.ex = ex
4371 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4372 
    result.write(oprot)
4373 
    oprot.writeMessageEnd()
4374 
    oprot.trans.flush()
94 ashish 4375 
 
3064 chandransh 4376 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4377 
    args = markOrdersAsDelivered_args()
304 ashish 4378 
    args.read(iprot)
4379 
    iprot.readMessageEnd()
3064 chandransh 4380 
    result = markOrdersAsDelivered_result()
4381 
    try:
4382 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4383 
    except TransactionServiceException, ex:
4384 
      result.ex = ex
4385 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4386 
    result.write(oprot)
4387 
    oprot.writeMessageEnd()
4388 
    oprot.trans.flush()
4389 
 
3064 chandransh 4390 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4391 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4392 
    args.read(iprot)
4393 
    iprot.readMessageEnd()
3064 chandransh 4394 
    result = markOrdersAsFailed_result()
4395 
    try:
4396 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4397 
    except TransactionServiceException, ex:
4398 
      result.ex = ex
4399 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4400 
    result.write(oprot)
4401 
    oprot.writeMessageEnd()
4402 
    oprot.trans.flush()
304 ashish 4403 
 
3064 chandransh 4404 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4405 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4406 
    args.read(iprot)
4407 
    iprot.readMessageEnd()
3064 chandransh 4408 
    result = updateNonDeliveryReason_result()
4409 
    try:
4410 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4411 
    except TransactionServiceException, ex:
4412 
      result.ex = ex
4413 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4414 
    result.write(oprot)
4415 
    oprot.writeMessageEnd()
4416 
    oprot.trans.flush()
1596 ankur.sing 4417 
 
3064 chandransh 4418 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4419 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4420 
    args.read(iprot)
4421 
    iprot.readMessageEnd()
3064 chandransh 4422 
    result = getUndeliveredOrders_result()
4423 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4424 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
2536 chandransh 4429 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4430 
    args = toggleDOAFlag_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = toggleDOAFlag_result()
4434 
    try:
4435 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4436 
    except TransactionServiceException, ex:
4437 
      result.ex = ex
4438 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
1886 ankur.sing 4442 
 
4454 rajveer 4443 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4444 
    args = markOrderDoaRequestReceived_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = markOrderDoaRequestReceived_result()
4448 
    try:
4449 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4450 
    except TransactionServiceException, ex:
4451 
      result.ex = ex
4452 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
4456 
 
4457 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4458 
    args = markOrderDoaRequestAuthorized_args()
4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
4461 
    result = markOrderDoaRequestAuthorized_result()
4462 
    try:
4463 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4464 
    except TransactionServiceException, ex:
4465 
      result.ex = ex
4466 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4467 
    result.write(oprot)
4468 
    oprot.writeMessageEnd()
4469 
    oprot.trans.flush()
4470 
 
4488 rajveer 4471 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4472 
    args = markOrderReturnRequestReceived_args()
4473 
    args.read(iprot)
4474 
    iprot.readMessageEnd()
4475 
    result = markOrderReturnRequestReceived_result()
4476 
    try:
4477 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4478 
    except TransactionServiceException, ex:
4479 
      result.ex = ex
4480 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
4485 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4486 
    args = markOrderReturnRequestAuthorized_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = markOrderReturnRequestAuthorized_result()
4490 
    try:
4491 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4492 
    except TransactionServiceException, ex:
4493 
      result.ex = ex
4494 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
2536 chandransh 4499 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4500 
    args = requestPickupNumber_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = requestPickupNumber_result()
4504 
    try:
4579 rajveer 4505 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4506 
    except TransactionServiceException, ex:
4507 
      result.ex = ex
4508 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
4512 
 
4513 
  def process_authorizePickup(self, seqid, iprot, oprot):
4514 
    args = authorizePickup_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = authorizePickup_result()
4518 
    try:
4519 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4520 
    except TransactionServiceException, ex:
4521 
      result.ex = ex
4522 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4523 
    result.write(oprot)
4524 
    oprot.writeMessageEnd()
4525 
    oprot.trans.flush()
4526 
 
2764 chandransh 4527 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4528 
    args = markDoasAsPickedUp_args()
4529 
    args.read(iprot)
4530 
    iprot.readMessageEnd()
4531 
    result = markDoasAsPickedUp_result()
4532 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4533 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4534 
    result.write(oprot)
4535 
    oprot.writeMessageEnd()
4536 
    oprot.trans.flush()
4537 
 
2616 chandransh 4538 
  def process_receiveReturn(self, seqid, iprot, oprot):
4539 
    args = receiveReturn_args()
2591 chandransh 4540 
    args.read(iprot)
4541 
    iprot.readMessageEnd()
2616 chandransh 4542 
    result = receiveReturn_result()
2591 chandransh 4543 
    try:
4479 rajveer 4544 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4545 
    except TransactionServiceException, ex:
4546 
      result.ex = ex
2616 chandransh 4547 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
2536 chandransh 4551 
 
2591 chandransh 4552 
  def process_validateDoa(self, seqid, iprot, oprot):
4553 
    args = validateDoa_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = validateDoa_result()
4557 
    try:
4558 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4559 
    except TransactionServiceException, ex:
4560 
      result.ex = ex
4561 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
4565 
 
4495 rajveer 4566 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4567 
    args = validateReturnProduct_args()
4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
4570 
    result = validateReturnProduct_result()
4571 
    try:
4572 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4573 
    except TransactionServiceException, ex:
4574 
      result.ex = ex
4575 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4576 
    result.write(oprot)
4577 
    oprot.writeMessageEnd()
4578 
    oprot.trans.flush()
4579 
 
2616 chandransh 4580 
  def process_reshipOrder(self, seqid, iprot, oprot):
4581 
    args = reshipOrder_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = reshipOrder_result()
4585 
    try:
4586 
      result.success = self._handler.reshipOrder(args.orderId)
4587 
    except TransactionServiceException, ex:
4588 
      result.ex = ex
4589 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4590 
    result.write(oprot)
4591 
    oprot.writeMessageEnd()
4592 
    oprot.trans.flush()
2591 chandransh 4593 
 
2616 chandransh 4594 
  def process_refundOrder(self, seqid, iprot, oprot):
4595 
    args = refundOrder_args()
4596 
    args.read(iprot)
4597 
    iprot.readMessageEnd()
4598 
    result = refundOrder_result()
4599 
    try:
3226 chandransh 4600 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4601 
    except TransactionServiceException, ex:
4602 
      result.ex = ex
4603 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
2690 chandransh 4608 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4609 
    args = getReturnOrders_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = getReturnOrders_result()
4613 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4614 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4615 
    result.write(oprot)
4616 
    oprot.writeMessageEnd()
4617 
    oprot.trans.flush()
2616 chandransh 4618 
 
2700 chandransh 4619 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4620 
    args = getReturnOrder_args()
4621 
    args.read(iprot)
4622 
    iprot.readMessageEnd()
4623 
    result = getReturnOrder_result()
4624 
    try:
4625 
      result.success = self._handler.getReturnOrder(args.id)
4626 
    except TransactionServiceException, ex:
4627 
      result.ex = ex
4628 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
4632 
 
2690 chandransh 4633 
  def process_processReturn(self, seqid, iprot, oprot):
4634 
    args = processReturn_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = processReturn_result()
4638 
    try:
4639 
      self._handler.processReturn(args.returnOrderId)
4640 
    except TransactionServiceException, ex:
4641 
      result.ex = ex
4642 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4643 
    result.write(oprot)
4644 
    oprot.writeMessageEnd()
4645 
    oprot.trans.flush()
4646 
 
2819 chandransh 4647 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4648 
    args = createPurchaseOrder_args()
4649 
    args.read(iprot)
4650 
    iprot.readMessageEnd()
4651 
    result = createPurchaseOrder_result()
4652 
    try:
4653 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4654 
    except TransactionServiceException, ex:
4655 
      result.ex = ex
4656 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4657 
    result.write(oprot)
4658 
    oprot.writeMessageEnd()
4659 
    oprot.trans.flush()
2690 chandransh 4660 
 
3451 chandransh 4661 
  def process_updateWeight(self, seqid, iprot, oprot):
4662 
    args = updateWeight_args()
4663 
    args.read(iprot)
4664 
    iprot.readMessageEnd()
4665 
    result = updateWeight_result()
4666 
    try:
4667 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4668 
    except TransactionServiceException, ex:
4669 
      result.ex = ex
4670 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4671 
    result.write(oprot)
4672 
    oprot.writeMessageEnd()
4673 
    oprot.trans.flush()
2819 chandransh 4674 
 
3469 chandransh 4675 
  def process_changeItem(self, seqid, iprot, oprot):
4676 
    args = changeItem_args()
4677 
    args.read(iprot)
4678 
    iprot.readMessageEnd()
4679 
    result = changeItem_result()
4680 
    try:
4681 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4682 
    except TransactionServiceException, ex:
4683 
      result.ex = ex
4684 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4685 
    result.write(oprot)
4686 
    oprot.writeMessageEnd()
4687 
    oprot.trans.flush()
3451 chandransh 4688 
 
3469 chandransh 4689 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4690 
    args = shiftToWarehouse_args()
4691 
    args.read(iprot)
4692 
    iprot.readMessageEnd()
4693 
    result = shiftToWarehouse_result()
4694 
    try:
4695 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4696 
    except TransactionServiceException, ex:
4697 
      result.ex = ex
4698 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4699 
    result.write(oprot)
4700 
    oprot.writeMessageEnd()
4701 
    oprot.trans.flush()
4702 
 
3553 chandransh 4703 
  def process_addDelayReason(self, seqid, iprot, oprot):
4704 
    args = addDelayReason_args()
4705 
    args.read(iprot)
4706 
    iprot.readMessageEnd()
4707 
    result = addDelayReason_result()
4708 
    try:
3986 chandransh 4709 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4710 
    except TransactionServiceException, ex:
4711 
      result.ex = ex
4712 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4713 
    result.write(oprot)
4714 
    oprot.writeMessageEnd()
4715 
    oprot.trans.flush()
3469 chandransh 4716 
 
3956 chandransh 4717 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4718 
    args = reconcileCodCollection_args()
4719 
    args.read(iprot)
4720 
    iprot.readMessageEnd()
4721 
    result = reconcileCodCollection_result()
4722 
    try:
4723 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4724 
    except TransactionServiceException, ex:
4725 
      result.ex = ex
4726 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
3553 chandransh 4730 
 
4008 mandeep.dh 4731 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4732 
    args = getTransactionsRequiringExtraProcessing_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = getTransactionsRequiringExtraProcessing_result()
4736 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4737 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
3956 chandransh 4741 
 
4008 mandeep.dh 4742 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4743 
    args = markTransactionAsProcessed_args()
4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
4746 
    result = markTransactionAsProcessed_result()
4747 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4748 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
4018 chandransh 4753 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4754 
    args = getItemWiseRiskyOrdersCount_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = getItemWiseRiskyOrdersCount_result()
4758 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4759 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4008 mandeep.dh 4763 
 
4295 varun.gupt 4764 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4765 
    args = getOrdersForItemIds_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = getOrdersForItemIds_result()
4769 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4770 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4771 
    result.write(oprot)
4772 
    oprot.writeMessageEnd()
4773 
    oprot.trans.flush()
4774 
 
4247 rajveer 4775 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4776 
    args = markOrderCancellationRequestReceived_args()
4777 
    args.read(iprot)
4778 
    iprot.readMessageEnd()
4779 
    result = markOrderCancellationRequestReceived_result()
4780 
    try:
4781 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4782 
    except TransactionServiceException, ex:
4783 
      result.ex = ex
4784 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4785 
    result.write(oprot)
4786 
    oprot.writeMessageEnd()
4787 
    oprot.trans.flush()
4018 chandransh 4788 
 
4247 rajveer 4789 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4790 
    args = markOrderCancellationRequestConfirmed_args()
4791 
    args.read(iprot)
4792 
    iprot.readMessageEnd()
4793 
    result = markOrderCancellationRequestConfirmed_result()
4794 
    try:
4795 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4796 
    except TransactionServiceException, ex:
4797 
      result.ex = ex
4798 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
4803 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4804 
    args = markOrderCancellationRequestDenied_args()
4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
4807 
    result = markOrderCancellationRequestDenied_result()
4808 
    try:
4809 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4810 
    except TransactionServiceException, ex:
4811 
      result.ex = ex
4812 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
4258 rajveer 4817 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4818 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
4258 rajveer 4821 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4822 
    try:
4258 rajveer 4823 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4824 
    except TransactionServiceException, ex:
4825 
      result.ex = ex
4258 rajveer 4826 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4827 
    result.write(oprot)
4828 
    oprot.writeMessageEnd()
4829 
    oprot.trans.flush()
4830 
 
4259 anupam.sin 4831 
  def process_refundTransaction(self, seqid, iprot, oprot):
4832 
    args = refundTransaction_args()
4833 
    args.read(iprot)
4834 
    iprot.readMessageEnd()
4835 
    result = refundTransaction_result()
4836 
    try:
4837 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4838 
    except TransactionServiceException, ex:
4839 
      result.ex = ex
4840 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4841 
    result.write(oprot)
4842 
    oprot.writeMessageEnd()
4843 
    oprot.trans.flush()
4247 rajveer 4844 
 
4324 mandeep.dh 4845 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4846 
    args = updateShipmentAddress_args()
4847 
    args.read(iprot)
4848 
    iprot.readMessageEnd()
4849 
    result = updateShipmentAddress_result()
4850 
    try:
4851 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4852 
    except TransactionServiceException, ex:
4853 
      result.ex = ex
4854 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4855 
    result.write(oprot)
4856 
    oprot.writeMessageEnd()
4857 
    oprot.trans.flush()
4858 
 
4285 rajveer 4859 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4860 
    args = acceptOrdersForItemId_args()
4861 
    args.read(iprot)
4862 
    iprot.readMessageEnd()
4863 
    result = acceptOrdersForItemId_result()
4864 
    try:
4865 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4866 
    except TransactionServiceException, ex:
4867 
      result.ex = ex
4868 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4869 
    result.write(oprot)
4870 
    oprot.writeMessageEnd()
4871 
    oprot.trans.flush()
4259 anupam.sin 4872 
 
4303 rajveer 4873 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4874 
    args = markOrdersAsPORaised_args()
4875 
    args.read(iprot)
4876 
    iprot.readMessageEnd()
4877 
    result = markOrdersAsPORaised_result()
4878 
    try:
4369 rajveer 4879 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4880 
    except TransactionServiceException, ex:
4881 
      result.ex = ex
4882 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4883 
    result.write(oprot)
4884 
    oprot.writeMessageEnd()
4885 
    oprot.trans.flush()
4285 rajveer 4886 
 
4303 rajveer 4887 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4888 
    args = markOrdersAsReversalInitiated_args()
4889 
    args.read(iprot)
4890 
    iprot.readMessageEnd()
4891 
    result = markOrdersAsReversalInitiated_result()
4892 
    try:
4369 rajveer 4893 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4894 
    except TransactionServiceException, ex:
4895 
      result.ex = ex
4896 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4897 
    result.write(oprot)
4898 
    oprot.writeMessageEnd()
4899 
    oprot.trans.flush()
4900 
 
4901 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4902 
    args = markOrdersAsNotAvailabke_args()
4903 
    args.read(iprot)
4904 
    iprot.readMessageEnd()
4905 
    result = markOrdersAsNotAvailabke_result()
4906 
    try:
4369 rajveer 4907 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4908 
    except TransactionServiceException, ex:
4909 
      result.ex = ex
4910 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4911 
    result.write(oprot)
4912 
    oprot.writeMessageEnd()
4913 
    oprot.trans.flush()
4914 
 
4369 rajveer 4915 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4916 
    args = markOrdersAsTimeout_args()
4917 
    args.read(iprot)
4918 
    iprot.readMessageEnd()
4919 
    result = markOrdersAsTimeout_result()
4920 
    try:
4921 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4922 
    except TransactionServiceException, ex:
4923 
      result.ex = ex
4924 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4925 
    result.write(oprot)
4926 
    oprot.writeMessageEnd()
4927 
    oprot.trans.flush()
4303 rajveer 4928 
 
4386 anupam.sin 4929 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4930 
    args = getOrderForAwb_args()
4931 
    args.read(iprot)
4932 
    iprot.readMessageEnd()
4933 
    result = getOrderForAwb_result()
4934 
    try:
4935 
      result.success = self._handler.getOrderForAwb(args.awb)
4936 
    except TransactionServiceException, ex:
4937 
      result.ex = ex
4938 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
4369 rajveer 4942 
 
4506 phani.kuma 4943 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
4944 
    args = getOrdersForProviderForStatus_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = getOrdersForProviderForStatus_result()
4948 
    try:
4949 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
4950 
    except TransactionServiceException, ex:
4951 
      result.ex = ex
4952 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
4953 
    result.write(oprot)
4954 
    oprot.writeMessageEnd()
4955 
    oprot.trans.flush()
4386 anupam.sin 4956 
 
4506 phani.kuma 4957 
 
94 ashish 4958 
# HELPER FUNCTIONS AND STRUCTURES
4959 
 
4960 
class createTransaction_args:
4961 
  """
4962 
  Attributes:
4963 
   - transaction
4964 
  """
4965 
 
4966 
  thrift_spec = (
4967 
    None, # 0
4968 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4969 
  )
4970 
 
4971 
  def __init__(self, transaction=None,):
4972 
    self.transaction = transaction
4973 
 
4974 
  def read(self, iprot):
4975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4977 
      return
4978 
    iprot.readStructBegin()
4979 
    while True:
4980 
      (fname, ftype, fid) = iprot.readFieldBegin()
4981 
      if ftype == TType.STOP:
4982 
        break
4983 
      if fid == 1:
4984 
        if ftype == TType.STRUCT:
4985 
          self.transaction = Transaction()
4986 
          self.transaction.read(iprot)
4987 
        else:
4988 
          iprot.skip(ftype)
4989 
      else:
4990 
        iprot.skip(ftype)
4991 
      iprot.readFieldEnd()
4992 
    iprot.readStructEnd()
4993 
 
4994 
  def write(self, oprot):
4995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4997 
      return
4998 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4999 
    if self.transaction is not None:
94 ashish 5000 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5001 
      self.transaction.write(oprot)
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 createTransaction_result:
5022 
  """
5023 
  Attributes:
132 ashish 5024 
   - success
94 ashish 5025 
   - ex
5026 
  """
5027 
 
5028 
  thrift_spec = (
132 ashish 5029 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5031 
  )
5032 
 
132 ashish 5033 
  def __init__(self, success=None, ex=None,):
5034 
    self.success = success
94 ashish 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
132 ashish 5046 
      if fid == 0:
5047 
        if ftype == TType.I64:
5048 
          self.success = iprot.readI64();
5049 
        else:
5050 
          iprot.skip(ftype)
5051 
      elif fid == 1:
94 ashish 5052 
        if ftype == TType.STRUCT:
5053 
          self.ex = TransactionServiceException()
5054 
          self.ex.read(iprot)
5055 
        else:
5056 
          iprot.skip(ftype)
5057 
      else:
5058 
        iprot.skip(ftype)
5059 
      iprot.readFieldEnd()
5060 
    iprot.readStructEnd()
5061 
 
5062 
  def write(self, oprot):
5063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5065 
      return
5066 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5067 
    if self.success is not None:
132 ashish 5068 
      oprot.writeFieldBegin('success', TType.I64, 0)
5069 
      oprot.writeI64(self.success)
5070 
      oprot.writeFieldEnd()
3431 rajveer 5071 
    if self.ex is not None:
94 ashish 5072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5073 
      self.ex.write(oprot)
5074 
      oprot.writeFieldEnd()
5075 
    oprot.writeFieldStop()
5076 
    oprot.writeStructEnd()
5077 
 
3431 rajveer 5078 
  def validate(self):
5079 
    return
5080 
 
5081 
 
94 ashish 5082 
  def __repr__(self):
5083 
    L = ['%s=%r' % (key, value)
5084 
      for key, value in self.__dict__.iteritems()]
5085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5086 
 
5087 
  def __eq__(self, other):
5088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5089 
 
5090 
  def __ne__(self, other):
5091 
    return not (self == other)
5092 
 
5093 
class getTransaction_args:
5094 
  """
5095 
  Attributes:
5096 
   - id
5097 
  """
5098 
 
5099 
  thrift_spec = (
5100 
    None, # 0
5101 
    (1, TType.I64, 'id', None, None, ), # 1
5102 
  )
5103 
 
5104 
  def __init__(self, id=None,):
5105 
    self.id = id
5106 
 
5107 
  def read(self, iprot):
5108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5110 
      return
5111 
    iprot.readStructBegin()
5112 
    while True:
5113 
      (fname, ftype, fid) = iprot.readFieldBegin()
5114 
      if ftype == TType.STOP:
5115 
        break
5116 
      if fid == 1:
5117 
        if ftype == TType.I64:
5118 
          self.id = iprot.readI64();
5119 
        else:
5120 
          iprot.skip(ftype)
5121 
      else:
5122 
        iprot.skip(ftype)
5123 
      iprot.readFieldEnd()
5124 
    iprot.readStructEnd()
5125 
 
5126 
  def write(self, oprot):
5127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5129 
      return
5130 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5131 
    if self.id is not None:
94 ashish 5132 
      oprot.writeFieldBegin('id', TType.I64, 1)
5133 
      oprot.writeI64(self.id)
5134 
      oprot.writeFieldEnd()
5135 
    oprot.writeFieldStop()
5136 
    oprot.writeStructEnd()
5137 
 
3431 rajveer 5138 
  def validate(self):
5139 
    return
5140 
 
5141 
 
94 ashish 5142 
  def __repr__(self):
5143 
    L = ['%s=%r' % (key, value)
5144 
      for key, value in self.__dict__.iteritems()]
5145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5146 
 
5147 
  def __eq__(self, other):
5148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5149 
 
5150 
  def __ne__(self, other):
5151 
    return not (self == other)
5152 
 
5153 
class getTransaction_result:
5154 
  """
5155 
  Attributes:
5156 
   - success
5157 
   - ex
5158 
  """
5159 
 
5160 
  thrift_spec = (
5161 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5163 
  )
5164 
 
5165 
  def __init__(self, success=None, ex=None,):
5166 
    self.success = success
5167 
    self.ex = ex
5168 
 
5169 
  def read(self, iprot):
5170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5172 
      return
5173 
    iprot.readStructBegin()
5174 
    while True:
5175 
      (fname, ftype, fid) = iprot.readFieldBegin()
5176 
      if ftype == TType.STOP:
5177 
        break
5178 
      if fid == 0:
5179 
        if ftype == TType.STRUCT:
5180 
          self.success = Transaction()
5181 
          self.success.read(iprot)
5182 
        else:
5183 
          iprot.skip(ftype)
5184 
      elif fid == 1:
5185 
        if ftype == TType.STRUCT:
5186 
          self.ex = TransactionServiceException()
5187 
          self.ex.read(iprot)
5188 
        else:
5189 
          iprot.skip(ftype)
5190 
      else:
5191 
        iprot.skip(ftype)
5192 
      iprot.readFieldEnd()
5193 
    iprot.readStructEnd()
5194 
 
5195 
  def write(self, oprot):
5196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5198 
      return
5199 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5200 
    if self.success is not None:
94 ashish 5201 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5202 
      self.success.write(oprot)
5203 
      oprot.writeFieldEnd()
3431 rajveer 5204 
    if self.ex is not None:
94 ashish 5205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5206 
      self.ex.write(oprot)
5207 
      oprot.writeFieldEnd()
5208 
    oprot.writeFieldStop()
5209 
    oprot.writeStructEnd()
5210 
 
3431 rajveer 5211 
  def validate(self):
5212 
    return
5213 
 
5214 
 
94 ashish 5215 
  def __repr__(self):
5216 
    L = ['%s=%r' % (key, value)
5217 
      for key, value in self.__dict__.iteritems()]
5218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5219 
 
5220 
  def __eq__(self, other):
5221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5222 
 
5223 
  def __ne__(self, other):
5224 
    return not (self == other)
5225 
 
5226 
class getTransactionsForCustomer_args:
5227 
  """
5228 
  Attributes:
5229 
   - customerId
5230 
   - from_date
5231 
   - to_date
5232 
   - status
5233 
  """
5234 
 
5235 
  thrift_spec = (
5236 
    None, # 0
5237 
    (1, TType.I64, 'customerId', None, None, ), # 1
5238 
    (2, TType.I64, 'from_date', None, None, ), # 2
5239 
    (3, TType.I64, 'to_date', None, None, ), # 3
5240 
    (4, TType.I32, 'status', None, None, ), # 4
5241 
  )
5242 
 
5243 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5244 
    self.customerId = customerId
5245 
    self.from_date = from_date
5246 
    self.to_date = to_date
5247 
    self.status = status
5248 
 
5249 
  def read(self, iprot):
5250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5252 
      return
5253 
    iprot.readStructBegin()
5254 
    while True:
5255 
      (fname, ftype, fid) = iprot.readFieldBegin()
5256 
      if ftype == TType.STOP:
5257 
        break
5258 
      if fid == 1:
5259 
        if ftype == TType.I64:
5260 
          self.customerId = iprot.readI64();
5261 
        else:
5262 
          iprot.skip(ftype)
5263 
      elif fid == 2:
5264 
        if ftype == TType.I64:
5265 
          self.from_date = iprot.readI64();
5266 
        else:
5267 
          iprot.skip(ftype)
5268 
      elif fid == 3:
5269 
        if ftype == TType.I64:
5270 
          self.to_date = iprot.readI64();
5271 
        else:
5272 
          iprot.skip(ftype)
5273 
      elif fid == 4:
5274 
        if ftype == TType.I32:
5275 
          self.status = iprot.readI32();
5276 
        else:
5277 
          iprot.skip(ftype)
5278 
      else:
5279 
        iprot.skip(ftype)
5280 
      iprot.readFieldEnd()
5281 
    iprot.readStructEnd()
5282 
 
5283 
  def write(self, oprot):
5284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5286 
      return
5287 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5288 
    if self.customerId is not None:
94 ashish 5289 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5290 
      oprot.writeI64(self.customerId)
5291 
      oprot.writeFieldEnd()
3431 rajveer 5292 
    if self.from_date is not None:
94 ashish 5293 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5294 
      oprot.writeI64(self.from_date)
5295 
      oprot.writeFieldEnd()
3431 rajveer 5296 
    if self.to_date is not None:
94 ashish 5297 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5298 
      oprot.writeI64(self.to_date)
5299 
      oprot.writeFieldEnd()
3431 rajveer 5300 
    if self.status is not None:
94 ashish 5301 
      oprot.writeFieldBegin('status', TType.I32, 4)
5302 
      oprot.writeI32(self.status)
5303 
      oprot.writeFieldEnd()
5304 
    oprot.writeFieldStop()
5305 
    oprot.writeStructEnd()
5306 
 
3431 rajveer 5307 
  def validate(self):
5308 
    return
5309 
 
5310 
 
94 ashish 5311 
  def __repr__(self):
5312 
    L = ['%s=%r' % (key, value)
5313 
      for key, value in self.__dict__.iteritems()]
5314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5315 
 
5316 
  def __eq__(self, other):
5317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5318 
 
5319 
  def __ne__(self, other):
5320 
    return not (self == other)
5321 
 
5322 
class getTransactionsForCustomer_result:
5323 
  """
5324 
  Attributes:
5325 
   - success
5326 
   - ex
5327 
  """
5328 
 
5329 
  thrift_spec = (
5330 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5332 
  )
5333 
 
5334 
  def __init__(self, success=None, ex=None,):
5335 
    self.success = success
5336 
    self.ex = ex
5337 
 
5338 
  def read(self, iprot):
5339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5341 
      return
5342 
    iprot.readStructBegin()
5343 
    while True:
5344 
      (fname, ftype, fid) = iprot.readFieldBegin()
5345 
      if ftype == TType.STOP:
5346 
        break
5347 
      if fid == 0:
5348 
        if ftype == TType.LIST:
5349 
          self.success = []
685 chandransh 5350 
          (_etype17, _size14) = iprot.readListBegin()
5351 
          for _i18 in xrange(_size14):
5352 
            _elem19 = Transaction()
5353 
            _elem19.read(iprot)
5354 
            self.success.append(_elem19)
94 ashish 5355 
          iprot.readListEnd()
5356 
        else:
5357 
          iprot.skip(ftype)
5358 
      elif fid == 1:
5359 
        if ftype == TType.STRUCT:
5360 
          self.ex = TransactionServiceException()
5361 
          self.ex.read(iprot)
5362 
        else:
5363 
          iprot.skip(ftype)
5364 
      else:
5365 
        iprot.skip(ftype)
5366 
      iprot.readFieldEnd()
5367 
    iprot.readStructEnd()
5368 
 
5369 
  def write(self, oprot):
5370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5372 
      return
5373 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5374 
    if self.success is not None:
94 ashish 5375 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5376 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5377 
      for iter20 in self.success:
5378 
        iter20.write(oprot)
94 ashish 5379 
      oprot.writeListEnd()
5380 
      oprot.writeFieldEnd()
3431 rajveer 5381 
    if self.ex is not None:
94 ashish 5382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5383 
      self.ex.write(oprot)
5384 
      oprot.writeFieldEnd()
5385 
    oprot.writeFieldStop()
5386 
    oprot.writeStructEnd()
5387 
 
3431 rajveer 5388 
  def validate(self):
5389 
    return
5390 
 
5391 
 
94 ashish 5392 
  def __repr__(self):
5393 
    L = ['%s=%r' % (key, value)
5394 
      for key, value in self.__dict__.iteritems()]
5395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5396 
 
5397 
  def __eq__(self, other):
5398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5399 
 
5400 
  def __ne__(self, other):
5401 
    return not (self == other)
5402 
 
132 ashish 5403 
class getTransactionsForShoppingCartId_args:
5404 
  """
5405 
  Attributes:
5406 
   - shoppingCartId
5407 
  """
5408 
 
5409 
  thrift_spec = (
5410 
    None, # 0
5411 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5412 
  )
5413 
 
5414 
  def __init__(self, shoppingCartId=None,):
5415 
    self.shoppingCartId = shoppingCartId
5416 
 
5417 
  def read(self, iprot):
5418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5420 
      return
5421 
    iprot.readStructBegin()
5422 
    while True:
5423 
      (fname, ftype, fid) = iprot.readFieldBegin()
5424 
      if ftype == TType.STOP:
5425 
        break
5426 
      if fid == 1:
5427 
        if ftype == TType.I64:
5428 
          self.shoppingCartId = iprot.readI64();
5429 
        else:
5430 
          iprot.skip(ftype)
5431 
      else:
5432 
        iprot.skip(ftype)
5433 
      iprot.readFieldEnd()
5434 
    iprot.readStructEnd()
5435 
 
5436 
  def write(self, oprot):
5437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5439 
      return
5440 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5441 
    if self.shoppingCartId is not None:
132 ashish 5442 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5443 
      oprot.writeI64(self.shoppingCartId)
5444 
      oprot.writeFieldEnd()
5445 
    oprot.writeFieldStop()
5446 
    oprot.writeStructEnd()
5447 
 
3431 rajveer 5448 
  def validate(self):
5449 
    return
5450 
 
5451 
 
132 ashish 5452 
  def __repr__(self):
5453 
    L = ['%s=%r' % (key, value)
5454 
      for key, value in self.__dict__.iteritems()]
5455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5456 
 
5457 
  def __eq__(self, other):
5458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5459 
 
5460 
  def __ne__(self, other):
5461 
    return not (self == other)
5462 
 
5463 
class getTransactionsForShoppingCartId_result:
5464 
  """
5465 
  Attributes:
5466 
   - success
5467 
   - ex
5468 
  """
5469 
 
5470 
  thrift_spec = (
5471 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5473 
  )
5474 
 
5475 
  def __init__(self, success=None, ex=None,):
5476 
    self.success = success
5477 
    self.ex = ex
5478 
 
5479 
  def read(self, iprot):
5480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5482 
      return
5483 
    iprot.readStructBegin()
5484 
    while True:
5485 
      (fname, ftype, fid) = iprot.readFieldBegin()
5486 
      if ftype == TType.STOP:
5487 
        break
5488 
      if fid == 0:
5489 
        if ftype == TType.LIST:
5490 
          self.success = []
685 chandransh 5491 
          (_etype24, _size21) = iprot.readListBegin()
5492 
          for _i25 in xrange(_size21):
5493 
            _elem26 = Transaction()
5494 
            _elem26.read(iprot)
5495 
            self.success.append(_elem26)
132 ashish 5496 
          iprot.readListEnd()
5497 
        else:
5498 
          iprot.skip(ftype)
5499 
      elif fid == 1:
5500 
        if ftype == TType.STRUCT:
5501 
          self.ex = TransactionServiceException()
5502 
          self.ex.read(iprot)
5503 
        else:
5504 
          iprot.skip(ftype)
5505 
      else:
5506 
        iprot.skip(ftype)
5507 
      iprot.readFieldEnd()
5508 
    iprot.readStructEnd()
5509 
 
5510 
  def write(self, oprot):
5511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5513 
      return
5514 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5515 
    if self.success is not None:
132 ashish 5516 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5517 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5518 
      for iter27 in self.success:
5519 
        iter27.write(oprot)
132 ashish 5520 
      oprot.writeListEnd()
5521 
      oprot.writeFieldEnd()
3431 rajveer 5522 
    if self.ex is not None:
132 ashish 5523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5524 
      self.ex.write(oprot)
5525 
      oprot.writeFieldEnd()
5526 
    oprot.writeFieldStop()
5527 
    oprot.writeStructEnd()
5528 
 
3431 rajveer 5529 
  def validate(self):
5530 
    return
5531 
 
5532 
 
132 ashish 5533 
  def __repr__(self):
5534 
    L = ['%s=%r' % (key, value)
5535 
      for key, value in self.__dict__.iteritems()]
5536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5537 
 
5538 
  def __eq__(self, other):
5539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5540 
 
5541 
  def __ne__(self, other):
5542 
    return not (self == other)
5543 
 
94 ashish 5544 
class getTransactionStatus_args:
5545 
  """
5546 
  Attributes:
5547 
   - transactionId
5548 
  """
5549 
 
5550 
  thrift_spec = (
5551 
    None, # 0
5552 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5553 
  )
5554 
 
5555 
  def __init__(self, transactionId=None,):
5556 
    self.transactionId = transactionId
5557 
 
5558 
  def read(self, iprot):
5559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5561 
      return
5562 
    iprot.readStructBegin()
5563 
    while True:
5564 
      (fname, ftype, fid) = iprot.readFieldBegin()
5565 
      if ftype == TType.STOP:
5566 
        break
5567 
      if fid == 1:
5568 
        if ftype == TType.I64:
5569 
          self.transactionId = iprot.readI64();
5570 
        else:
5571 
          iprot.skip(ftype)
5572 
      else:
5573 
        iprot.skip(ftype)
5574 
      iprot.readFieldEnd()
5575 
    iprot.readStructEnd()
5576 
 
5577 
  def write(self, oprot):
5578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5580 
      return
5581 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5582 
    if self.transactionId is not None:
94 ashish 5583 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5584 
      oprot.writeI64(self.transactionId)
5585 
      oprot.writeFieldEnd()
5586 
    oprot.writeFieldStop()
5587 
    oprot.writeStructEnd()
5588 
 
3431 rajveer 5589 
  def validate(self):
5590 
    return
5591 
 
5592 
 
94 ashish 5593 
  def __repr__(self):
5594 
    L = ['%s=%r' % (key, value)
5595 
      for key, value in self.__dict__.iteritems()]
5596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5597 
 
5598 
  def __eq__(self, other):
5599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5600 
 
5601 
  def __ne__(self, other):
5602 
    return not (self == other)
5603 
 
5604 
class getTransactionStatus_result:
5605 
  """
5606 
  Attributes:
5607 
   - success
5608 
   - ex
5609 
  """
5610 
 
5611 
  thrift_spec = (
5612 
    (0, TType.I32, 'success', None, None, ), # 0
5613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5614 
  )
5615 
 
5616 
  def __init__(self, success=None, ex=None,):
5617 
    self.success = success
5618 
    self.ex = ex
5619 
 
5620 
  def read(self, iprot):
5621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5623 
      return
5624 
    iprot.readStructBegin()
5625 
    while True:
5626 
      (fname, ftype, fid) = iprot.readFieldBegin()
5627 
      if ftype == TType.STOP:
5628 
        break
5629 
      if fid == 0:
5630 
        if ftype == TType.I32:
5631 
          self.success = iprot.readI32();
5632 
        else:
5633 
          iprot.skip(ftype)
5634 
      elif fid == 1:
5635 
        if ftype == TType.STRUCT:
5636 
          self.ex = TransactionServiceException()
5637 
          self.ex.read(iprot)
5638 
        else:
5639 
          iprot.skip(ftype)
5640 
      else:
5641 
        iprot.skip(ftype)
5642 
      iprot.readFieldEnd()
5643 
    iprot.readStructEnd()
5644 
 
5645 
  def write(self, oprot):
5646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5648 
      return
5649 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5650 
    if self.success is not None:
94 ashish 5651 
      oprot.writeFieldBegin('success', TType.I32, 0)
5652 
      oprot.writeI32(self.success)
5653 
      oprot.writeFieldEnd()
3431 rajveer 5654 
    if self.ex is not None:
94 ashish 5655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5656 
      self.ex.write(oprot)
5657 
      oprot.writeFieldEnd()
5658 
    oprot.writeFieldStop()
5659 
    oprot.writeStructEnd()
5660 
 
3431 rajveer 5661 
  def validate(self):
5662 
    return
5663 
 
5664 
 
94 ashish 5665 
  def __repr__(self):
5666 
    L = ['%s=%r' % (key, value)
5667 
      for key, value in self.__dict__.iteritems()]
5668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5669 
 
5670 
  def __eq__(self, other):
5671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5672 
 
5673 
  def __ne__(self, other):
5674 
    return not (self == other)
5675 
 
5676 
class changeTransactionStatus_args:
5677 
  """
5678 
  Attributes:
5679 
   - transactionId
5680 
   - status
5681 
   - description
5682 
  """
5683 
 
5684 
  thrift_spec = (
5685 
    None, # 0
5686 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5687 
    (2, TType.I32, 'status', None, None, ), # 2
5688 
    (3, TType.STRING, 'description', None, None, ), # 3
5689 
  )
5690 
 
5691 
  def __init__(self, transactionId=None, status=None, description=None,):
5692 
    self.transactionId = transactionId
5693 
    self.status = status
5694 
    self.description = description
5695 
 
5696 
  def read(self, iprot):
5697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5699 
      return
5700 
    iprot.readStructBegin()
5701 
    while True:
5702 
      (fname, ftype, fid) = iprot.readFieldBegin()
5703 
      if ftype == TType.STOP:
5704 
        break
5705 
      if fid == 1:
5706 
        if ftype == TType.I64:
5707 
          self.transactionId = iprot.readI64();
5708 
        else:
5709 
          iprot.skip(ftype)
5710 
      elif fid == 2:
5711 
        if ftype == TType.I32:
5712 
          self.status = iprot.readI32();
5713 
        else:
5714 
          iprot.skip(ftype)
5715 
      elif fid == 3:
5716 
        if ftype == TType.STRING:
5717 
          self.description = iprot.readString();
5718 
        else:
5719 
          iprot.skip(ftype)
5720 
      else:
5721 
        iprot.skip(ftype)
5722 
      iprot.readFieldEnd()
5723 
    iprot.readStructEnd()
5724 
 
5725 
  def write(self, oprot):
5726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5728 
      return
5729 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5730 
    if self.transactionId is not None:
94 ashish 5731 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5732 
      oprot.writeI64(self.transactionId)
5733 
      oprot.writeFieldEnd()
3431 rajveer 5734 
    if self.status is not None:
94 ashish 5735 
      oprot.writeFieldBegin('status', TType.I32, 2)
5736 
      oprot.writeI32(self.status)
5737 
      oprot.writeFieldEnd()
3431 rajveer 5738 
    if self.description is not None:
94 ashish 5739 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5740 
      oprot.writeString(self.description)
5741 
      oprot.writeFieldEnd()
5742 
    oprot.writeFieldStop()
5743 
    oprot.writeStructEnd()
5744 
 
3431 rajveer 5745 
  def validate(self):
5746 
    return
5747 
 
5748 
 
94 ashish 5749 
  def __repr__(self):
5750 
    L = ['%s=%r' % (key, value)
5751 
      for key, value in self.__dict__.iteritems()]
5752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5753 
 
5754 
  def __eq__(self, other):
5755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5756 
 
5757 
  def __ne__(self, other):
5758 
    return not (self == other)
5759 
 
5760 
class changeTransactionStatus_result:
5761 
  """
5762 
  Attributes:
5763 
   - success
5764 
   - ex
5765 
  """
5766 
 
5767 
  thrift_spec = (
5768 
    (0, TType.BOOL, 'success', None, None, ), # 0
5769 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5770 
  )
5771 
 
5772 
  def __init__(self, success=None, ex=None,):
5773 
    self.success = success
5774 
    self.ex = ex
5775 
 
5776 
  def read(self, iprot):
5777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5779 
      return
5780 
    iprot.readStructBegin()
5781 
    while True:
5782 
      (fname, ftype, fid) = iprot.readFieldBegin()
5783 
      if ftype == TType.STOP:
5784 
        break
5785 
      if fid == 0:
5786 
        if ftype == TType.BOOL:
5787 
          self.success = iprot.readBool();
5788 
        else:
5789 
          iprot.skip(ftype)
5790 
      elif fid == 1:
5791 
        if ftype == TType.STRUCT:
5792 
          self.ex = TransactionServiceException()
5793 
          self.ex.read(iprot)
5794 
        else:
5795 
          iprot.skip(ftype)
5796 
      else:
5797 
        iprot.skip(ftype)
5798 
      iprot.readFieldEnd()
5799 
    iprot.readStructEnd()
5800 
 
5801 
  def write(self, oprot):
5802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5804 
      return
5805 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5806 
    if self.success is not None:
94 ashish 5807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5808 
      oprot.writeBool(self.success)
5809 
      oprot.writeFieldEnd()
3431 rajveer 5810 
    if self.ex is not None:
94 ashish 5811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5812 
      self.ex.write(oprot)
5813 
      oprot.writeFieldEnd()
5814 
    oprot.writeFieldStop()
5815 
    oprot.writeStructEnd()
5816 
 
3431 rajveer 5817 
  def validate(self):
5818 
    return
5819 
 
5820 
 
94 ashish 5821 
  def __repr__(self):
5822 
    L = ['%s=%r' % (key, value)
5823 
      for key, value in self.__dict__.iteritems()]
5824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5825 
 
5826 
  def __eq__(self, other):
5827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5828 
 
5829 
  def __ne__(self, other):
5830 
    return not (self == other)
5831 
 
1398 varun.gupt 5832 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5833 
  """
5834 
  Attributes:
5835 
   - transactionId
5836 
  """
5837 
 
5838 
  thrift_spec = (
5839 
    None, # 0
5840 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5841 
  )
5842 
 
5843 
  def __init__(self, transactionId=None,):
5844 
    self.transactionId = transactionId
5845 
 
5846 
  def read(self, iprot):
5847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5849 
      return
5850 
    iprot.readStructBegin()
5851 
    while True:
5852 
      (fname, ftype, fid) = iprot.readFieldBegin()
5853 
      if ftype == TType.STOP:
5854 
        break
5855 
      if fid == 1:
5856 
        if ftype == TType.I64:
5857 
          self.transactionId = iprot.readI64();
5858 
        else:
5859 
          iprot.skip(ftype)
5860 
      else:
5861 
        iprot.skip(ftype)
5862 
      iprot.readFieldEnd()
5863 
    iprot.readStructEnd()
5864 
 
5865 
  def write(self, oprot):
5866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5868 
      return
1398 varun.gupt 5869 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5870 
    if self.transactionId is not None:
1382 varun.gupt 5871 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5872 
      oprot.writeI64(self.transactionId)
5873 
      oprot.writeFieldEnd()
5874 
    oprot.writeFieldStop()
5875 
    oprot.writeStructEnd()
5876 
 
3431 rajveer 5877 
  def validate(self):
5878 
    return
5879 
 
5880 
 
1382 varun.gupt 5881 
  def __repr__(self):
5882 
    L = ['%s=%r' % (key, value)
5883 
      for key, value in self.__dict__.iteritems()]
5884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5885 
 
5886 
  def __eq__(self, other):
5887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5888 
 
5889 
  def __ne__(self, other):
5890 
    return not (self == other)
5891 
 
1398 varun.gupt 5892 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5893 
  """
5894 
  Attributes:
5895 
   - success
5896 
   - ex
5897 
  """
5898 
 
5899 
  thrift_spec = (
5900 
    (0, TType.BOOL, 'success', None, None, ), # 0
5901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5902 
  )
5903 
 
5904 
  def __init__(self, success=None, ex=None,):
5905 
    self.success = success
5906 
    self.ex = ex
5907 
 
5908 
  def read(self, iprot):
5909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5911 
      return
5912 
    iprot.readStructBegin()
5913 
    while True:
5914 
      (fname, ftype, fid) = iprot.readFieldBegin()
5915 
      if ftype == TType.STOP:
5916 
        break
5917 
      if fid == 0:
5918 
        if ftype == TType.BOOL:
5919 
          self.success = iprot.readBool();
5920 
        else:
5921 
          iprot.skip(ftype)
5922 
      elif fid == 1:
5923 
        if ftype == TType.STRUCT:
5924 
          self.ex = TransactionServiceException()
5925 
          self.ex.read(iprot)
5926 
        else:
5927 
          iprot.skip(ftype)
5928 
      else:
5929 
        iprot.skip(ftype)
5930 
      iprot.readFieldEnd()
5931 
    iprot.readStructEnd()
5932 
 
5933 
  def write(self, oprot):
5934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5936 
      return
1398 varun.gupt 5937 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5938 
    if self.success is not None:
1382 varun.gupt 5939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5940 
      oprot.writeBool(self.success)
5941 
      oprot.writeFieldEnd()
3431 rajveer 5942 
    if self.ex is not None:
1382 varun.gupt 5943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5944 
      self.ex.write(oprot)
5945 
      oprot.writeFieldEnd()
5946 
    oprot.writeFieldStop()
5947 
    oprot.writeStructEnd()
5948 
 
3431 rajveer 5949 
  def validate(self):
5950 
    return
5951 
 
5952 
 
1382 varun.gupt 5953 
  def __repr__(self):
5954 
    L = ['%s=%r' % (key, value)
5955 
      for key, value in self.__dict__.iteritems()]
5956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5957 
 
5958 
  def __eq__(self, other):
5959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5960 
 
5961 
  def __ne__(self, other):
5962 
    return not (self == other)
5963 
 
483 rajveer 5964 
class getAllOrders_args:
94 ashish 5965 
  """
5966 
  Attributes:
483 rajveer 5967 
   - status
5968 
   - from_date
5969 
   - to_date
5970 
   - warehouse_id
94 ashish 5971 
  """
5972 
 
5973 
  thrift_spec = (
5974 
    None, # 0
483 rajveer 5975 
    (1, TType.I32, 'status', None, None, ), # 1
5976 
    (2, TType.I64, 'from_date', None, None, ), # 2
5977 
    (3, TType.I64, 'to_date', None, None, ), # 3
5978 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5979 
  )
5980 
 
483 rajveer 5981 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5982 
    self.status = status
5983 
    self.from_date = from_date
5984 
    self.to_date = to_date
5985 
    self.warehouse_id = warehouse_id
94 ashish 5986 
 
5987 
  def read(self, iprot):
5988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5990 
      return
5991 
    iprot.readStructBegin()
5992 
    while True:
5993 
      (fname, ftype, fid) = iprot.readFieldBegin()
5994 
      if ftype == TType.STOP:
5995 
        break
5996 
      if fid == 1:
483 rajveer 5997 
        if ftype == TType.I32:
5998 
          self.status = iprot.readI32();
94 ashish 5999 
        else:
6000 
          iprot.skip(ftype)
483 rajveer 6001 
      elif fid == 2:
6002 
        if ftype == TType.I64:
6003 
          self.from_date = iprot.readI64();
94 ashish 6004 
        else:
6005 
          iprot.skip(ftype)
483 rajveer 6006 
      elif fid == 3:
6007 
        if ftype == TType.I64:
6008 
          self.to_date = iprot.readI64();
94 ashish 6009 
        else:
6010 
          iprot.skip(ftype)
483 rajveer 6011 
      elif fid == 4:
94 ashish 6012 
        if ftype == TType.I64:
483 rajveer 6013 
          self.warehouse_id = iprot.readI64();
94 ashish 6014 
        else:
6015 
          iprot.skip(ftype)
6016 
      else:
6017 
        iprot.skip(ftype)
6018 
      iprot.readFieldEnd()
6019 
    iprot.readStructEnd()
6020 
 
6021 
  def write(self, oprot):
6022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6024 
      return
483 rajveer 6025 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6026 
    if self.status is not None:
483 rajveer 6027 
      oprot.writeFieldBegin('status', TType.I32, 1)
6028 
      oprot.writeI32(self.status)
94 ashish 6029 
      oprot.writeFieldEnd()
3431 rajveer 6030 
    if self.from_date is not None:
483 rajveer 6031 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6032 
      oprot.writeI64(self.from_date)
94 ashish 6033 
      oprot.writeFieldEnd()
3431 rajveer 6034 
    if self.to_date is not None:
483 rajveer 6035 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6036 
      oprot.writeI64(self.to_date)
94 ashish 6037 
      oprot.writeFieldEnd()
3431 rajveer 6038 
    if self.warehouse_id is not None:
483 rajveer 6039 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6040 
      oprot.writeI64(self.warehouse_id)
94 ashish 6041 
      oprot.writeFieldEnd()
6042 
    oprot.writeFieldStop()
6043 
    oprot.writeStructEnd()
6044 
 
3431 rajveer 6045 
  def validate(self):
6046 
    return
6047 
 
6048 
 
94 ashish 6049 
  def __repr__(self):
6050 
    L = ['%s=%r' % (key, value)
6051 
      for key, value in self.__dict__.iteritems()]
6052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6053 
 
6054 
  def __eq__(self, other):
6055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6056 
 
6057 
  def __ne__(self, other):
6058 
    return not (self == other)
6059 
 
483 rajveer 6060 
class getAllOrders_result:
94 ashish 6061 
  """
6062 
  Attributes:
6063 
   - success
6064 
   - ex
6065 
  """
6066 
 
6067 
  thrift_spec = (
483 rajveer 6068 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6070 
  )
6071 
 
6072 
  def __init__(self, success=None, ex=None,):
6073 
    self.success = success
6074 
    self.ex = ex
6075 
 
6076 
  def read(self, iprot):
6077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6079 
      return
6080 
    iprot.readStructBegin()
6081 
    while True:
6082 
      (fname, ftype, fid) = iprot.readFieldBegin()
6083 
      if ftype == TType.STOP:
6084 
        break
6085 
      if fid == 0:
483 rajveer 6086 
        if ftype == TType.LIST:
6087 
          self.success = []
685 chandransh 6088 
          (_etype31, _size28) = iprot.readListBegin()
6089 
          for _i32 in xrange(_size28):
6090 
            _elem33 = Order()
6091 
            _elem33.read(iprot)
6092 
            self.success.append(_elem33)
483 rajveer 6093 
          iprot.readListEnd()
94 ashish 6094 
        else:
6095 
          iprot.skip(ftype)
6096 
      elif fid == 1:
6097 
        if ftype == TType.STRUCT:
6098 
          self.ex = TransactionServiceException()
6099 
          self.ex.read(iprot)
6100 
        else:
6101 
          iprot.skip(ftype)
6102 
      else:
6103 
        iprot.skip(ftype)
6104 
      iprot.readFieldEnd()
6105 
    iprot.readStructEnd()
6106 
 
6107 
  def write(self, oprot):
6108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6110 
      return
483 rajveer 6111 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6112 
    if self.success is not None:
483 rajveer 6113 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6114 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6115 
      for iter34 in self.success:
6116 
        iter34.write(oprot)
483 rajveer 6117 
      oprot.writeListEnd()
94 ashish 6118 
      oprot.writeFieldEnd()
3431 rajveer 6119 
    if self.ex is not None:
94 ashish 6120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6121 
      self.ex.write(oprot)
6122 
      oprot.writeFieldEnd()
6123 
    oprot.writeFieldStop()
6124 
    oprot.writeStructEnd()
6125 
 
3431 rajveer 6126 
  def validate(self):
6127 
    return
6128 
 
6129 
 
94 ashish 6130 
  def __repr__(self):
6131 
    L = ['%s=%r' % (key, value)
6132 
      for key, value in self.__dict__.iteritems()]
6133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6134 
 
6135 
  def __eq__(self, other):
6136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6137 
 
6138 
  def __ne__(self, other):
6139 
    return not (self == other)
6140 
 
4133 chandransh 6141 
class getOrdersInBatch_args:
6142 
  """
6143 
  Attributes:
6144 
   - statuses
6145 
   - offset
6146 
   - limit
6147 
   - warehouse_id
6148 
  """
6149 
 
6150 
  thrift_spec = (
6151 
    None, # 0
6152 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6153 
    (2, TType.I64, 'offset', None, None, ), # 2
6154 
    (3, TType.I64, 'limit', None, None, ), # 3
6155 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6156 
  )
6157 
 
6158 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6159 
    self.statuses = statuses
6160 
    self.offset = offset
6161 
    self.limit = limit
6162 
    self.warehouse_id = warehouse_id
6163 
 
6164 
  def read(self, iprot):
6165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6167 
      return
6168 
    iprot.readStructBegin()
6169 
    while True:
6170 
      (fname, ftype, fid) = iprot.readFieldBegin()
6171 
      if ftype == TType.STOP:
6172 
        break
6173 
      if fid == 1:
6174 
        if ftype == TType.LIST:
6175 
          self.statuses = []
6176 
          (_etype38, _size35) = iprot.readListBegin()
6177 
          for _i39 in xrange(_size35):
6178 
            _elem40 = iprot.readI32();
6179 
            self.statuses.append(_elem40)
6180 
          iprot.readListEnd()
6181 
        else:
6182 
          iprot.skip(ftype)
6183 
      elif fid == 2:
6184 
        if ftype == TType.I64:
6185 
          self.offset = iprot.readI64();
6186 
        else:
6187 
          iprot.skip(ftype)
6188 
      elif fid == 3:
6189 
        if ftype == TType.I64:
6190 
          self.limit = iprot.readI64();
6191 
        else:
6192 
          iprot.skip(ftype)
6193 
      elif fid == 4:
6194 
        if ftype == TType.I64:
6195 
          self.warehouse_id = iprot.readI64();
6196 
        else:
6197 
          iprot.skip(ftype)
6198 
      else:
6199 
        iprot.skip(ftype)
6200 
      iprot.readFieldEnd()
6201 
    iprot.readStructEnd()
6202 
 
6203 
  def write(self, oprot):
6204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6206 
      return
6207 
    oprot.writeStructBegin('getOrdersInBatch_args')
6208 
    if self.statuses is not None:
6209 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6210 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6211 
      for iter41 in self.statuses:
6212 
        oprot.writeI32(iter41)
6213 
      oprot.writeListEnd()
6214 
      oprot.writeFieldEnd()
6215 
    if self.offset is not None:
6216 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6217 
      oprot.writeI64(self.offset)
6218 
      oprot.writeFieldEnd()
6219 
    if self.limit is not None:
6220 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6221 
      oprot.writeI64(self.limit)
6222 
      oprot.writeFieldEnd()
6223 
    if self.warehouse_id is not None:
6224 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6225 
      oprot.writeI64(self.warehouse_id)
6226 
      oprot.writeFieldEnd()
6227 
    oprot.writeFieldStop()
6228 
    oprot.writeStructEnd()
6229 
 
6230 
  def validate(self):
6231 
    return
6232 
 
6233 
 
6234 
  def __repr__(self):
6235 
    L = ['%s=%r' % (key, value)
6236 
      for key, value in self.__dict__.iteritems()]
6237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6238 
 
6239 
  def __eq__(self, other):
6240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6241 
 
6242 
  def __ne__(self, other):
6243 
    return not (self == other)
6244 
 
6245 
class getOrdersInBatch_result:
6246 
  """
6247 
  Attributes:
6248 
   - success
6249 
   - ex
6250 
  """
6251 
 
6252 
  thrift_spec = (
6253 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6254 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6255 
  )
6256 
 
6257 
  def __init__(self, success=None, ex=None,):
6258 
    self.success = success
6259 
    self.ex = ex
6260 
 
6261 
  def read(self, iprot):
6262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6264 
      return
6265 
    iprot.readStructBegin()
6266 
    while True:
6267 
      (fname, ftype, fid) = iprot.readFieldBegin()
6268 
      if ftype == TType.STOP:
6269 
        break
6270 
      if fid == 0:
6271 
        if ftype == TType.LIST:
6272 
          self.success = []
6273 
          (_etype45, _size42) = iprot.readListBegin()
6274 
          for _i46 in xrange(_size42):
6275 
            _elem47 = Order()
6276 
            _elem47.read(iprot)
6277 
            self.success.append(_elem47)
6278 
          iprot.readListEnd()
6279 
        else:
6280 
          iprot.skip(ftype)
6281 
      elif fid == 1:
6282 
        if ftype == TType.STRUCT:
6283 
          self.ex = TransactionServiceException()
6284 
          self.ex.read(iprot)
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      else:
6288 
        iprot.skip(ftype)
6289 
      iprot.readFieldEnd()
6290 
    iprot.readStructEnd()
6291 
 
6292 
  def write(self, oprot):
6293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6295 
      return
6296 
    oprot.writeStructBegin('getOrdersInBatch_result')
6297 
    if self.success is not None:
6298 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6299 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6300 
      for iter48 in self.success:
6301 
        iter48.write(oprot)
6302 
      oprot.writeListEnd()
6303 
      oprot.writeFieldEnd()
6304 
    if self.ex is not None:
6305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6306 
      self.ex.write(oprot)
6307 
      oprot.writeFieldEnd()
6308 
    oprot.writeFieldStop()
6309 
    oprot.writeStructEnd()
6310 
 
6311 
  def validate(self):
6312 
    return
6313 
 
6314 
 
6315 
  def __repr__(self):
6316 
    L = ['%s=%r' % (key, value)
6317 
      for key, value in self.__dict__.iteritems()]
6318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6319 
 
6320 
  def __eq__(self, other):
6321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6322 
 
6323 
  def __ne__(self, other):
6324 
    return not (self == other)
6325 
 
6326 
class getOrderCount_args:
6327 
  """
6328 
  Attributes:
6329 
   - statuses
6330 
   - warehouseId
6331 
  """
6332 
 
6333 
  thrift_spec = (
6334 
    None, # 0
6335 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6336 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6337 
  )
6338 
 
6339 
  def __init__(self, statuses=None, warehouseId=None,):
6340 
    self.statuses = statuses
6341 
    self.warehouseId = warehouseId
6342 
 
6343 
  def read(self, iprot):
6344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6346 
      return
6347 
    iprot.readStructBegin()
6348 
    while True:
6349 
      (fname, ftype, fid) = iprot.readFieldBegin()
6350 
      if ftype == TType.STOP:
6351 
        break
6352 
      if fid == 1:
6353 
        if ftype == TType.LIST:
6354 
          self.statuses = []
6355 
          (_etype52, _size49) = iprot.readListBegin()
6356 
          for _i53 in xrange(_size49):
6357 
            _elem54 = iprot.readI32();
6358 
            self.statuses.append(_elem54)
6359 
          iprot.readListEnd()
6360 
        else:
6361 
          iprot.skip(ftype)
6362 
      elif fid == 2:
6363 
        if ftype == TType.I64:
6364 
          self.warehouseId = iprot.readI64();
6365 
        else:
6366 
          iprot.skip(ftype)
6367 
      else:
6368 
        iprot.skip(ftype)
6369 
      iprot.readFieldEnd()
6370 
    iprot.readStructEnd()
6371 
 
6372 
  def write(self, oprot):
6373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6375 
      return
6376 
    oprot.writeStructBegin('getOrderCount_args')
6377 
    if self.statuses is not None:
6378 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6379 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6380 
      for iter55 in self.statuses:
6381 
        oprot.writeI32(iter55)
6382 
      oprot.writeListEnd()
6383 
      oprot.writeFieldEnd()
6384 
    if self.warehouseId is not None:
6385 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6386 
      oprot.writeI64(self.warehouseId)
6387 
      oprot.writeFieldEnd()
6388 
    oprot.writeFieldStop()
6389 
    oprot.writeStructEnd()
6390 
 
6391 
  def validate(self):
6392 
    return
6393 
 
6394 
 
6395 
  def __repr__(self):
6396 
    L = ['%s=%r' % (key, value)
6397 
      for key, value in self.__dict__.iteritems()]
6398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6399 
 
6400 
  def __eq__(self, other):
6401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6402 
 
6403 
  def __ne__(self, other):
6404 
    return not (self == other)
6405 
 
6406 
class getOrderCount_result:
6407 
  """
6408 
  Attributes:
6409 
   - success
6410 
   - ex
6411 
  """
6412 
 
6413 
  thrift_spec = (
6414 
    (0, TType.I32, 'success', None, None, ), # 0
6415 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6416 
  )
6417 
 
6418 
  def __init__(self, success=None, ex=None,):
6419 
    self.success = success
6420 
    self.ex = ex
6421 
 
6422 
  def read(self, iprot):
6423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6425 
      return
6426 
    iprot.readStructBegin()
6427 
    while True:
6428 
      (fname, ftype, fid) = iprot.readFieldBegin()
6429 
      if ftype == TType.STOP:
6430 
        break
6431 
      if fid == 0:
6432 
        if ftype == TType.I32:
6433 
          self.success = iprot.readI32();
6434 
        else:
6435 
          iprot.skip(ftype)
6436 
      elif fid == 1:
6437 
        if ftype == TType.STRUCT:
6438 
          self.ex = TransactionServiceException()
6439 
          self.ex.read(iprot)
6440 
        else:
6441 
          iprot.skip(ftype)
6442 
      else:
6443 
        iprot.skip(ftype)
6444 
      iprot.readFieldEnd()
6445 
    iprot.readStructEnd()
6446 
 
6447 
  def write(self, oprot):
6448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6450 
      return
6451 
    oprot.writeStructBegin('getOrderCount_result')
6452 
    if self.success is not None:
6453 
      oprot.writeFieldBegin('success', TType.I32, 0)
6454 
      oprot.writeI32(self.success)
6455 
      oprot.writeFieldEnd()
6456 
    if self.ex is not None:
6457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6458 
      self.ex.write(oprot)
6459 
      oprot.writeFieldEnd()
6460 
    oprot.writeFieldStop()
6461 
    oprot.writeStructEnd()
6462 
 
6463 
  def validate(self):
6464 
    return
6465 
 
6466 
 
6467 
  def __repr__(self):
6468 
    L = ['%s=%r' % (key, value)
6469 
      for key, value in self.__dict__.iteritems()]
6470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6471 
 
6472 
  def __eq__(self, other):
6473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6474 
 
6475 
  def __ne__(self, other):
6476 
    return not (self == other)
6477 
 
999 varun.gupt 6478 
class getOrdersByBillingDate_args:
6479 
  """
6480 
  Attributes:
6481 
   - status
6482 
   - start_billing_date
6483 
   - end_billing_date
6484 
   - warehouse_id
6485 
  """
6486 
 
6487 
  thrift_spec = (
6488 
    None, # 0
6489 
    (1, TType.I32, 'status', None, None, ), # 1
6490 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6491 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6492 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6493 
  )
6494 
 
6495 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6496 
    self.status = status
6497 
    self.start_billing_date = start_billing_date
6498 
    self.end_billing_date = end_billing_date
6499 
    self.warehouse_id = warehouse_id
6500 
 
6501 
  def read(self, iprot):
6502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6504 
      return
6505 
    iprot.readStructBegin()
6506 
    while True:
6507 
      (fname, ftype, fid) = iprot.readFieldBegin()
6508 
      if ftype == TType.STOP:
6509 
        break
6510 
      if fid == 1:
6511 
        if ftype == TType.I32:
6512 
          self.status = iprot.readI32();
6513 
        else:
6514 
          iprot.skip(ftype)
6515 
      elif fid == 2:
6516 
        if ftype == TType.I64:
6517 
          self.start_billing_date = iprot.readI64();
6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      elif fid == 3:
6521 
        if ftype == TType.I64:
6522 
          self.end_billing_date = iprot.readI64();
6523 
        else:
6524 
          iprot.skip(ftype)
6525 
      elif fid == 4:
6526 
        if ftype == TType.I64:
6527 
          self.warehouse_id = iprot.readI64();
6528 
        else:
6529 
          iprot.skip(ftype)
6530 
      else:
6531 
        iprot.skip(ftype)
6532 
      iprot.readFieldEnd()
6533 
    iprot.readStructEnd()
6534 
 
6535 
  def write(self, oprot):
6536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6538 
      return
6539 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6540 
    if self.status is not None:
999 varun.gupt 6541 
      oprot.writeFieldBegin('status', TType.I32, 1)
6542 
      oprot.writeI32(self.status)
6543 
      oprot.writeFieldEnd()
3431 rajveer 6544 
    if self.start_billing_date is not None:
999 varun.gupt 6545 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6546 
      oprot.writeI64(self.start_billing_date)
6547 
      oprot.writeFieldEnd()
3431 rajveer 6548 
    if self.end_billing_date is not None:
999 varun.gupt 6549 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6550 
      oprot.writeI64(self.end_billing_date)
6551 
      oprot.writeFieldEnd()
3431 rajveer 6552 
    if self.warehouse_id is not None:
999 varun.gupt 6553 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6554 
      oprot.writeI64(self.warehouse_id)
6555 
      oprot.writeFieldEnd()
6556 
    oprot.writeFieldStop()
6557 
    oprot.writeStructEnd()
6558 
 
3431 rajveer 6559 
  def validate(self):
6560 
    return
6561 
 
6562 
 
999 varun.gupt 6563 
  def __repr__(self):
6564 
    L = ['%s=%r' % (key, value)
6565 
      for key, value in self.__dict__.iteritems()]
6566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6567 
 
6568 
  def __eq__(self, other):
6569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6570 
 
6571 
  def __ne__(self, other):
6572 
    return not (self == other)
6573 
 
6574 
class getOrdersByBillingDate_result:
6575 
  """
6576 
  Attributes:
6577 
   - success
6578 
   - ex
6579 
  """
6580 
 
6581 
  thrift_spec = (
6582 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6584 
  )
6585 
 
6586 
  def __init__(self, success=None, ex=None,):
6587 
    self.success = success
6588 
    self.ex = ex
6589 
 
6590 
  def read(self, iprot):
6591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6593 
      return
6594 
    iprot.readStructBegin()
6595 
    while True:
6596 
      (fname, ftype, fid) = iprot.readFieldBegin()
6597 
      if ftype == TType.STOP:
6598 
        break
6599 
      if fid == 0:
6600 
        if ftype == TType.LIST:
6601 
          self.success = []
4133 chandransh 6602 
          (_etype59, _size56) = iprot.readListBegin()
6603 
          for _i60 in xrange(_size56):
6604 
            _elem61 = Order()
6605 
            _elem61.read(iprot)
6606 
            self.success.append(_elem61)
999 varun.gupt 6607 
          iprot.readListEnd()
6608 
        else:
6609 
          iprot.skip(ftype)
6610 
      elif fid == 1:
6611 
        if ftype == TType.STRUCT:
6612 
          self.ex = TransactionServiceException()
6613 
          self.ex.read(iprot)
6614 
        else:
6615 
          iprot.skip(ftype)
6616 
      else:
6617 
        iprot.skip(ftype)
6618 
      iprot.readFieldEnd()
6619 
    iprot.readStructEnd()
6620 
 
6621 
  def write(self, oprot):
6622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6624 
      return
6625 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6626 
    if self.success is not None:
999 varun.gupt 6627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6629 
      for iter62 in self.success:
6630 
        iter62.write(oprot)
999 varun.gupt 6631 
      oprot.writeListEnd()
6632 
      oprot.writeFieldEnd()
3431 rajveer 6633 
    if self.ex is not None:
999 varun.gupt 6634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6635 
      self.ex.write(oprot)
6636 
      oprot.writeFieldEnd()
6637 
    oprot.writeFieldStop()
6638 
    oprot.writeStructEnd()
6639 
 
3431 rajveer 6640 
  def validate(self):
6641 
    return
6642 
 
6643 
 
999 varun.gupt 6644 
  def __repr__(self):
6645 
    L = ['%s=%r' % (key, value)
6646 
      for key, value in self.__dict__.iteritems()]
6647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6648 
 
6649 
  def __eq__(self, other):
6650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6651 
 
6652 
  def __ne__(self, other):
6653 
    return not (self == other)
6654 
 
3427 chandransh 6655 
class getOrdersByShippingDate_args:
6656 
  """
6657 
  Attributes:
6658 
   - fromShippingDate
6659 
   - toShippingDate
6660 
   - providerId
6661 
   - warehouseId
3451 chandransh 6662 
   - cod
3427 chandransh 6663 
  """
6664 
 
6665 
  thrift_spec = (
6666 
    None, # 0
6667 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6668 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6669 
    (3, TType.I64, 'providerId', None, None, ), # 3
6670 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6671 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6672 
  )
6673 
 
3451 chandransh 6674 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6675 
    self.fromShippingDate = fromShippingDate
6676 
    self.toShippingDate = toShippingDate
6677 
    self.providerId = providerId
6678 
    self.warehouseId = warehouseId
3451 chandransh 6679 
    self.cod = cod
3427 chandransh 6680 
 
6681 
  def read(self, iprot):
6682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6684 
      return
6685 
    iprot.readStructBegin()
6686 
    while True:
6687 
      (fname, ftype, fid) = iprot.readFieldBegin()
6688 
      if ftype == TType.STOP:
6689 
        break
6690 
      if fid == 1:
6691 
        if ftype == TType.I64:
6692 
          self.fromShippingDate = iprot.readI64();
6693 
        else:
6694 
          iprot.skip(ftype)
6695 
      elif fid == 2:
6696 
        if ftype == TType.I64:
6697 
          self.toShippingDate = iprot.readI64();
6698 
        else:
6699 
          iprot.skip(ftype)
6700 
      elif fid == 3:
6701 
        if ftype == TType.I64:
6702 
          self.providerId = iprot.readI64();
6703 
        else:
6704 
          iprot.skip(ftype)
6705 
      elif fid == 4:
6706 
        if ftype == TType.I64:
6707 
          self.warehouseId = iprot.readI64();
6708 
        else:
6709 
          iprot.skip(ftype)
3451 chandransh 6710 
      elif fid == 5:
6711 
        if ftype == TType.BOOL:
6712 
          self.cod = iprot.readBool();
6713 
        else:
6714 
          iprot.skip(ftype)
3427 chandransh 6715 
      else:
6716 
        iprot.skip(ftype)
6717 
      iprot.readFieldEnd()
6718 
    iprot.readStructEnd()
6719 
 
6720 
  def write(self, oprot):
6721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6723 
      return
6724 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6725 
    if self.fromShippingDate is not None:
3427 chandransh 6726 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6727 
      oprot.writeI64(self.fromShippingDate)
6728 
      oprot.writeFieldEnd()
3431 rajveer 6729 
    if self.toShippingDate is not None:
3427 chandransh 6730 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6731 
      oprot.writeI64(self.toShippingDate)
6732 
      oprot.writeFieldEnd()
3431 rajveer 6733 
    if self.providerId is not None:
3427 chandransh 6734 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6735 
      oprot.writeI64(self.providerId)
6736 
      oprot.writeFieldEnd()
3431 rajveer 6737 
    if self.warehouseId is not None:
3427 chandransh 6738 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6739 
      oprot.writeI64(self.warehouseId)
6740 
      oprot.writeFieldEnd()
3451 chandransh 6741 
    if self.cod is not None:
6742 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6743 
      oprot.writeBool(self.cod)
6744 
      oprot.writeFieldEnd()
3427 chandransh 6745 
    oprot.writeFieldStop()
6746 
    oprot.writeStructEnd()
6747 
 
3431 rajveer 6748 
  def validate(self):
6749 
    return
6750 
 
6751 
 
3427 chandransh 6752 
  def __repr__(self):
6753 
    L = ['%s=%r' % (key, value)
6754 
      for key, value in self.__dict__.iteritems()]
6755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6756 
 
6757 
  def __eq__(self, other):
6758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6759 
 
6760 
  def __ne__(self, other):
6761 
    return not (self == other)
6762 
 
6763 
class getOrdersByShippingDate_result:
6764 
  """
6765 
  Attributes:
6766 
   - success
6767 
   - ex
6768 
  """
6769 
 
6770 
  thrift_spec = (
6771 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6773 
  )
6774 
 
6775 
  def __init__(self, success=None, ex=None,):
6776 
    self.success = success
6777 
    self.ex = ex
6778 
 
6779 
  def read(self, iprot):
6780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6782 
      return
6783 
    iprot.readStructBegin()
6784 
    while True:
6785 
      (fname, ftype, fid) = iprot.readFieldBegin()
6786 
      if ftype == TType.STOP:
6787 
        break
6788 
      if fid == 0:
6789 
        if ftype == TType.LIST:
6790 
          self.success = []
4133 chandransh 6791 
          (_etype66, _size63) = iprot.readListBegin()
6792 
          for _i67 in xrange(_size63):
6793 
            _elem68 = Order()
6794 
            _elem68.read(iprot)
6795 
            self.success.append(_elem68)
3427 chandransh 6796 
          iprot.readListEnd()
6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      elif fid == 1:
6800 
        if ftype == TType.STRUCT:
6801 
          self.ex = TransactionServiceException()
6802 
          self.ex.read(iprot)
6803 
        else:
6804 
          iprot.skip(ftype)
6805 
      else:
6806 
        iprot.skip(ftype)
6807 
      iprot.readFieldEnd()
6808 
    iprot.readStructEnd()
6809 
 
6810 
  def write(self, oprot):
6811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6813 
      return
6814 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6815 
    if self.success is not None:
3427 chandransh 6816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6818 
      for iter69 in self.success:
6819 
        iter69.write(oprot)
3427 chandransh 6820 
      oprot.writeListEnd()
6821 
      oprot.writeFieldEnd()
3431 rajveer 6822 
    if self.ex is not None:
3427 chandransh 6823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6824 
      self.ex.write(oprot)
6825 
      oprot.writeFieldEnd()
6826 
    oprot.writeFieldStop()
6827 
    oprot.writeStructEnd()
6828 
 
3431 rajveer 6829 
  def validate(self):
6830 
    return
6831 
 
6832 
 
3427 chandransh 6833 
  def __repr__(self):
6834 
    L = ['%s=%r' % (key, value)
6835 
      for key, value in self.__dict__.iteritems()]
6836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6837 
 
6838 
  def __eq__(self, other):
6839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6840 
 
6841 
  def __ne__(self, other):
6842 
    return not (self == other)
6843 
 
1382 varun.gupt 6844 
class getReturnableOrdersForCustomer_args:
6845 
  """
6846 
  Attributes:
6847 
   - customer_id
6848 
   - limit
6849 
  """
6850 
 
6851 
  thrift_spec = (
6852 
    None, # 0
6853 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6854 
    (2, TType.I64, 'limit', None, None, ), # 2
6855 
  )
6856 
 
6857 
  def __init__(self, customer_id=None, limit=None,):
6858 
    self.customer_id = customer_id
6859 
    self.limit = limit
6860 
 
6861 
  def read(self, iprot):
6862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6864 
      return
6865 
    iprot.readStructBegin()
6866 
    while True:
6867 
      (fname, ftype, fid) = iprot.readFieldBegin()
6868 
      if ftype == TType.STOP:
6869 
        break
6870 
      if fid == 1:
6871 
        if ftype == TType.I64:
6872 
          self.customer_id = iprot.readI64();
6873 
        else:
6874 
          iprot.skip(ftype)
6875 
      elif fid == 2:
6876 
        if ftype == TType.I64:
6877 
          self.limit = iprot.readI64();
6878 
        else:
6879 
          iprot.skip(ftype)
6880 
      else:
6881 
        iprot.skip(ftype)
6882 
      iprot.readFieldEnd()
6883 
    iprot.readStructEnd()
6884 
 
6885 
  def write(self, oprot):
6886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6888 
      return
6889 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6890 
    if self.customer_id is not None:
1382 varun.gupt 6891 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6892 
      oprot.writeI64(self.customer_id)
6893 
      oprot.writeFieldEnd()
3431 rajveer 6894 
    if self.limit is not None:
1382 varun.gupt 6895 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6896 
      oprot.writeI64(self.limit)
6897 
      oprot.writeFieldEnd()
6898 
    oprot.writeFieldStop()
6899 
    oprot.writeStructEnd()
6900 
 
3431 rajveer 6901 
  def validate(self):
6902 
    return
6903 
 
6904 
 
1382 varun.gupt 6905 
  def __repr__(self):
6906 
    L = ['%s=%r' % (key, value)
6907 
      for key, value in self.__dict__.iteritems()]
6908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6909 
 
6910 
  def __eq__(self, other):
6911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6912 
 
6913 
  def __ne__(self, other):
6914 
    return not (self == other)
6915 
 
6916 
class getReturnableOrdersForCustomer_result:
6917 
  """
6918 
  Attributes:
6919 
   - success
6920 
   - ex
6921 
  """
6922 
 
6923 
  thrift_spec = (
6924 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6926 
  )
6927 
 
6928 
  def __init__(self, success=None, ex=None,):
6929 
    self.success = success
6930 
    self.ex = ex
6931 
 
6932 
  def read(self, iprot):
6933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6935 
      return
6936 
    iprot.readStructBegin()
6937 
    while True:
6938 
      (fname, ftype, fid) = iprot.readFieldBegin()
6939 
      if ftype == TType.STOP:
6940 
        break
6941 
      if fid == 0:
6942 
        if ftype == TType.LIST:
6943 
          self.success = []
4133 chandransh 6944 
          (_etype73, _size70) = iprot.readListBegin()
6945 
          for _i74 in xrange(_size70):
6946 
            _elem75 = iprot.readI64();
6947 
            self.success.append(_elem75)
1382 varun.gupt 6948 
          iprot.readListEnd()
6949 
        else:
6950 
          iprot.skip(ftype)
6951 
      elif fid == 1:
6952 
        if ftype == TType.STRUCT:
6953 
          self.ex = TransactionServiceException()
6954 
          self.ex.read(iprot)
6955 
        else:
6956 
          iprot.skip(ftype)
6957 
      else:
6958 
        iprot.skip(ftype)
6959 
      iprot.readFieldEnd()
6960 
    iprot.readStructEnd()
6961 
 
6962 
  def write(self, oprot):
6963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6965 
      return
6966 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6967 
    if self.success is not None:
1382 varun.gupt 6968 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6969 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6970 
      for iter76 in self.success:
6971 
        oprot.writeI64(iter76)
1382 varun.gupt 6972 
      oprot.writeListEnd()
6973 
      oprot.writeFieldEnd()
3431 rajveer 6974 
    if self.ex is not None:
1382 varun.gupt 6975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6976 
      self.ex.write(oprot)
6977 
      oprot.writeFieldEnd()
6978 
    oprot.writeFieldStop()
6979 
    oprot.writeStructEnd()
6980 
 
3431 rajveer 6981 
  def validate(self):
6982 
    return
6983 
 
6984 
 
1382 varun.gupt 6985 
  def __repr__(self):
6986 
    L = ['%s=%r' % (key, value)
6987 
      for key, value in self.__dict__.iteritems()]
6988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6989 
 
6990 
  def __eq__(self, other):
6991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6992 
 
6993 
  def __ne__(self, other):
6994 
    return not (self == other)
6995 
 
6996 
class getCancellableOrdersForCustomer_args:
6997 
  """
6998 
  Attributes:
6999 
   - customer_id
7000 
   - limit
7001 
  """
7002 
 
7003 
  thrift_spec = (
7004 
    None, # 0
7005 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7006 
    (2, TType.I64, 'limit', None, None, ), # 2
7007 
  )
7008 
 
7009 
  def __init__(self, customer_id=None, limit=None,):
7010 
    self.customer_id = customer_id
7011 
    self.limit = limit
7012 
 
7013 
  def read(self, iprot):
7014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7016 
      return
7017 
    iprot.readStructBegin()
7018 
    while True:
7019 
      (fname, ftype, fid) = iprot.readFieldBegin()
7020 
      if ftype == TType.STOP:
7021 
        break
7022 
      if fid == 1:
7023 
        if ftype == TType.I64:
7024 
          self.customer_id = iprot.readI64();
7025 
        else:
7026 
          iprot.skip(ftype)
7027 
      elif fid == 2:
7028 
        if ftype == TType.I64:
7029 
          self.limit = iprot.readI64();
7030 
        else:
7031 
          iprot.skip(ftype)
7032 
      else:
7033 
        iprot.skip(ftype)
7034 
      iprot.readFieldEnd()
7035 
    iprot.readStructEnd()
7036 
 
7037 
  def write(self, oprot):
7038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7040 
      return
7041 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7042 
    if self.customer_id is not None:
1382 varun.gupt 7043 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7044 
      oprot.writeI64(self.customer_id)
7045 
      oprot.writeFieldEnd()
3431 rajveer 7046 
    if self.limit is not None:
1382 varun.gupt 7047 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7048 
      oprot.writeI64(self.limit)
7049 
      oprot.writeFieldEnd()
7050 
    oprot.writeFieldStop()
7051 
    oprot.writeStructEnd()
7052 
 
3431 rajveer 7053 
  def validate(self):
7054 
    return
7055 
 
7056 
 
1382 varun.gupt 7057 
  def __repr__(self):
7058 
    L = ['%s=%r' % (key, value)
7059 
      for key, value in self.__dict__.iteritems()]
7060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7061 
 
7062 
  def __eq__(self, other):
7063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7064 
 
7065 
  def __ne__(self, other):
7066 
    return not (self == other)
7067 
 
7068 
class getCancellableOrdersForCustomer_result:
7069 
  """
7070 
  Attributes:
7071 
   - success
7072 
   - ex
7073 
  """
7074 
 
7075 
  thrift_spec = (
7076 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7078 
  )
7079 
 
7080 
  def __init__(self, success=None, ex=None,):
7081 
    self.success = success
7082 
    self.ex = ex
7083 
 
7084 
  def read(self, iprot):
7085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7087 
      return
7088 
    iprot.readStructBegin()
7089 
    while True:
7090 
      (fname, ftype, fid) = iprot.readFieldBegin()
7091 
      if ftype == TType.STOP:
7092 
        break
7093 
      if fid == 0:
7094 
        if ftype == TType.LIST:
7095 
          self.success = []
4133 chandransh 7096 
          (_etype80, _size77) = iprot.readListBegin()
7097 
          for _i81 in xrange(_size77):
7098 
            _elem82 = iprot.readI64();
7099 
            self.success.append(_elem82)
1382 varun.gupt 7100 
          iprot.readListEnd()
7101 
        else:
7102 
          iprot.skip(ftype)
7103 
      elif fid == 1:
7104 
        if ftype == TType.STRUCT:
7105 
          self.ex = TransactionServiceException()
7106 
          self.ex.read(iprot)
7107 
        else:
7108 
          iprot.skip(ftype)
7109 
      else:
7110 
        iprot.skip(ftype)
7111 
      iprot.readFieldEnd()
7112 
    iprot.readStructEnd()
7113 
 
7114 
  def write(self, oprot):
7115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7117 
      return
7118 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7119 
    if self.success is not None:
1382 varun.gupt 7120 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7121 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7122 
      for iter83 in self.success:
7123 
        oprot.writeI64(iter83)
1382 varun.gupt 7124 
      oprot.writeListEnd()
7125 
      oprot.writeFieldEnd()
3431 rajveer 7126 
    if self.ex is not None:
1382 varun.gupt 7127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7128 
      self.ex.write(oprot)
7129 
      oprot.writeFieldEnd()
7130 
    oprot.writeFieldStop()
7131 
    oprot.writeStructEnd()
7132 
 
3431 rajveer 7133 
  def validate(self):
7134 
    return
7135 
 
7136 
 
1382 varun.gupt 7137 
  def __repr__(self):
7138 
    L = ['%s=%r' % (key, value)
7139 
      for key, value in self.__dict__.iteritems()]
7140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7141 
 
7142 
  def __eq__(self, other):
7143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7144 
 
7145 
  def __ne__(self, other):
7146 
    return not (self == other)
7147 
 
483 rajveer 7148 
class changeOrderStatus_args:
94 ashish 7149 
  """
7150 
  Attributes:
483 rajveer 7151 
   - orderId
7152 
   - status
7153 
   - description
94 ashish 7154 
  """
7155 
 
7156 
  thrift_spec = (
7157 
    None, # 0
483 rajveer 7158 
    (1, TType.I64, 'orderId', None, None, ), # 1
7159 
    (2, TType.I32, 'status', None, None, ), # 2
7160 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7161 
  )
7162 
 
483 rajveer 7163 
  def __init__(self, orderId=None, status=None, description=None,):
7164 
    self.orderId = orderId
7165 
    self.status = status
7166 
    self.description = description
94 ashish 7167 
 
7168 
  def read(self, iprot):
7169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7171 
      return
7172 
    iprot.readStructBegin()
7173 
    while True:
7174 
      (fname, ftype, fid) = iprot.readFieldBegin()
7175 
      if ftype == TType.STOP:
7176 
        break
7177 
      if fid == 1:
7178 
        if ftype == TType.I64:
483 rajveer 7179 
          self.orderId = iprot.readI64();
94 ashish 7180 
        else:
7181 
          iprot.skip(ftype)
7182 
      elif fid == 2:
483 rajveer 7183 
        if ftype == TType.I32:
7184 
          self.status = iprot.readI32();
94 ashish 7185 
        else:
7186 
          iprot.skip(ftype)
483 rajveer 7187 
      elif fid == 3:
7188 
        if ftype == TType.STRING:
7189 
          self.description = iprot.readString();
7190 
        else:
7191 
          iprot.skip(ftype)
94 ashish 7192 
      else:
7193 
        iprot.skip(ftype)
7194 
      iprot.readFieldEnd()
7195 
    iprot.readStructEnd()
7196 
 
7197 
  def write(self, oprot):
7198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7200 
      return
483 rajveer 7201 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7202 
    if self.orderId is not None:
483 rajveer 7203 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7204 
      oprot.writeI64(self.orderId)
94 ashish 7205 
      oprot.writeFieldEnd()
3431 rajveer 7206 
    if self.status is not None:
483 rajveer 7207 
      oprot.writeFieldBegin('status', TType.I32, 2)
7208 
      oprot.writeI32(self.status)
94 ashish 7209 
      oprot.writeFieldEnd()
3431 rajveer 7210 
    if self.description is not None:
483 rajveer 7211 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7212 
      oprot.writeString(self.description)
7213 
      oprot.writeFieldEnd()
94 ashish 7214 
    oprot.writeFieldStop()
7215 
    oprot.writeStructEnd()
7216 
 
3431 rajveer 7217 
  def validate(self):
7218 
    return
7219 
 
7220 
 
94 ashish 7221 
  def __repr__(self):
7222 
    L = ['%s=%r' % (key, value)
7223 
      for key, value in self.__dict__.iteritems()]
7224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7225 
 
7226 
  def __eq__(self, other):
7227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7228 
 
7229 
  def __ne__(self, other):
7230 
    return not (self == other)
7231 
 
483 rajveer 7232 
class changeOrderStatus_result:
94 ashish 7233 
  """
7234 
  Attributes:
7235 
   - success
7236 
   - ex
7237 
  """
7238 
 
7239 
  thrift_spec = (
7240 
    (0, TType.BOOL, 'success', None, None, ), # 0
7241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7242 
  )
7243 
 
7244 
  def __init__(self, success=None, ex=None,):
7245 
    self.success = success
7246 
    self.ex = ex
7247 
 
7248 
  def read(self, iprot):
7249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7251 
      return
7252 
    iprot.readStructBegin()
7253 
    while True:
7254 
      (fname, ftype, fid) = iprot.readFieldBegin()
7255 
      if ftype == TType.STOP:
7256 
        break
7257 
      if fid == 0:
7258 
        if ftype == TType.BOOL:
7259 
          self.success = iprot.readBool();
7260 
        else:
7261 
          iprot.skip(ftype)
7262 
      elif fid == 1:
7263 
        if ftype == TType.STRUCT:
7264 
          self.ex = TransactionServiceException()
7265 
          self.ex.read(iprot)
7266 
        else:
7267 
          iprot.skip(ftype)
7268 
      else:
7269 
        iprot.skip(ftype)
7270 
      iprot.readFieldEnd()
7271 
    iprot.readStructEnd()
7272 
 
7273 
  def write(self, oprot):
7274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7276 
      return
483 rajveer 7277 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7278 
    if self.success is not None:
94 ashish 7279 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7280 
      oprot.writeBool(self.success)
7281 
      oprot.writeFieldEnd()
3431 rajveer 7282 
    if self.ex is not None:
94 ashish 7283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7284 
      self.ex.write(oprot)
7285 
      oprot.writeFieldEnd()
7286 
    oprot.writeFieldStop()
7287 
    oprot.writeStructEnd()
7288 
 
3431 rajveer 7289 
  def validate(self):
7290 
    return
7291 
 
7292 
 
94 ashish 7293 
  def __repr__(self):
7294 
    L = ['%s=%r' % (key, value)
7295 
      for key, value in self.__dict__.iteritems()]
7296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7297 
 
7298 
  def __eq__(self, other):
7299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7300 
 
7301 
  def __ne__(self, other):
7302 
    return not (self == other)
7303 
 
3064 chandransh 7304 
class getOrdersForTransaction_args:
494 rajveer 7305 
  """
7306 
  Attributes:
3064 chandransh 7307 
   - transactionId
7308 
   - customerId
494 rajveer 7309 
  """
7310 
 
7311 
  thrift_spec = (
7312 
    None, # 0
3064 chandransh 7313 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7314 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7315 
  )
7316 
 
3064 chandransh 7317 
  def __init__(self, transactionId=None, customerId=None,):
7318 
    self.transactionId = transactionId
7319 
    self.customerId = customerId
494 rajveer 7320 
 
7321 
  def read(self, iprot):
7322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7324 
      return
7325 
    iprot.readStructBegin()
7326 
    while True:
7327 
      (fname, ftype, fid) = iprot.readFieldBegin()
7328 
      if ftype == TType.STOP:
7329 
        break
7330 
      if fid == 1:
7331 
        if ftype == TType.I64:
3064 chandransh 7332 
          self.transactionId = iprot.readI64();
494 rajveer 7333 
        else:
7334 
          iprot.skip(ftype)
7335 
      elif fid == 2:
3064 chandransh 7336 
        if ftype == TType.I64:
7337 
          self.customerId = iprot.readI64();
494 rajveer 7338 
        else:
7339 
          iprot.skip(ftype)
7340 
      else:
7341 
        iprot.skip(ftype)
7342 
      iprot.readFieldEnd()
7343 
    iprot.readStructEnd()
7344 
 
7345 
  def write(self, oprot):
7346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7348 
      return
3064 chandransh 7349 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7350 
    if self.transactionId is not None:
3064 chandransh 7351 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7352 
      oprot.writeI64(self.transactionId)
494 rajveer 7353 
      oprot.writeFieldEnd()
3431 rajveer 7354 
    if self.customerId is not None:
3064 chandransh 7355 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7356 
      oprot.writeI64(self.customerId)
494 rajveer 7357 
      oprot.writeFieldEnd()
7358 
    oprot.writeFieldStop()
7359 
    oprot.writeStructEnd()
7360 
 
3431 rajveer 7361 
  def validate(self):
7362 
    return
7363 
 
7364 
 
494 rajveer 7365 
  def __repr__(self):
7366 
    L = ['%s=%r' % (key, value)
7367 
      for key, value in self.__dict__.iteritems()]
7368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7369 
 
7370 
  def __eq__(self, other):
7371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7372 
 
7373 
  def __ne__(self, other):
7374 
    return not (self == other)
7375 
 
3064 chandransh 7376 
class getOrdersForTransaction_result:
494 rajveer 7377 
  """
7378 
  Attributes:
7379 
   - success
7380 
   - ex
7381 
  """
7382 
 
7383 
  thrift_spec = (
3064 chandransh 7384 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7386 
  )
7387 
 
7388 
  def __init__(self, success=None, ex=None,):
7389 
    self.success = success
7390 
    self.ex = ex
7391 
 
7392 
  def read(self, iprot):
7393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7395 
      return
7396 
    iprot.readStructBegin()
7397 
    while True:
7398 
      (fname, ftype, fid) = iprot.readFieldBegin()
7399 
      if ftype == TType.STOP:
7400 
        break
7401 
      if fid == 0:
3064 chandransh 7402 
        if ftype == TType.LIST:
7403 
          self.success = []
4133 chandransh 7404 
          (_etype87, _size84) = iprot.readListBegin()
7405 
          for _i88 in xrange(_size84):
7406 
            _elem89 = Order()
7407 
            _elem89.read(iprot)
7408 
            self.success.append(_elem89)
3064 chandransh 7409 
          iprot.readListEnd()
494 rajveer 7410 
        else:
7411 
          iprot.skip(ftype)
7412 
      elif fid == 1:
7413 
        if ftype == TType.STRUCT:
7414 
          self.ex = TransactionServiceException()
7415 
          self.ex.read(iprot)
7416 
        else:
7417 
          iprot.skip(ftype)
7418 
      else:
7419 
        iprot.skip(ftype)
7420 
      iprot.readFieldEnd()
7421 
    iprot.readStructEnd()
7422 
 
7423 
  def write(self, oprot):
7424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7426 
      return
3064 chandransh 7427 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7428 
    if self.success is not None:
3064 chandransh 7429 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7430 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7431 
      for iter90 in self.success:
7432 
        iter90.write(oprot)
3064 chandransh 7433 
      oprot.writeListEnd()
494 rajveer 7434 
      oprot.writeFieldEnd()
3431 rajveer 7435 
    if self.ex is not None:
494 rajveer 7436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7437 
      self.ex.write(oprot)
7438 
      oprot.writeFieldEnd()
7439 
    oprot.writeFieldStop()
7440 
    oprot.writeStructEnd()
7441 
 
3431 rajveer 7442 
  def validate(self):
7443 
    return
7444 
 
7445 
 
494 rajveer 7446 
  def __repr__(self):
7447 
    L = ['%s=%r' % (key, value)
7448 
      for key, value in self.__dict__.iteritems()]
7449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7450 
 
7451 
  def __eq__(self, other):
7452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7453 
 
7454 
  def __ne__(self, other):
7455 
    return not (self == other)
7456 
 
3064 chandransh 7457 
class getOrdersForCustomer_args:
1149 chandransh 7458 
  """
7459 
  Attributes:
3064 chandransh 7460 
   - customerId
7461 
   - from_date
7462 
   - to_date
7463 
   - statuses
1149 chandransh 7464 
  """
7465 
 
7466 
  thrift_spec = (
7467 
    None, # 0
3064 chandransh 7468 
    (1, TType.I64, 'customerId', None, None, ), # 1
7469 
    (2, TType.I64, 'from_date', None, None, ), # 2
7470 
    (3, TType.I64, 'to_date', None, None, ), # 3
7471 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7472 
  )
7473 
 
3064 chandransh 7474 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7475 
    self.customerId = customerId
7476 
    self.from_date = from_date
7477 
    self.to_date = to_date
7478 
    self.statuses = statuses
1149 chandransh 7479 
 
7480 
  def read(self, iprot):
7481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7483 
      return
7484 
    iprot.readStructBegin()
7485 
    while True:
7486 
      (fname, ftype, fid) = iprot.readFieldBegin()
7487 
      if ftype == TType.STOP:
7488 
        break
7489 
      if fid == 1:
7490 
        if ftype == TType.I64:
3064 chandransh 7491 
          self.customerId = iprot.readI64();
1149 chandransh 7492 
        else:
7493 
          iprot.skip(ftype)
7494 
      elif fid == 2:
7495 
        if ftype == TType.I64:
3064 chandransh 7496 
          self.from_date = iprot.readI64();
1149 chandransh 7497 
        else:
7498 
          iprot.skip(ftype)
2783 chandransh 7499 
      elif fid == 3:
7500 
        if ftype == TType.I64:
3064 chandransh 7501 
          self.to_date = iprot.readI64();
2783 chandransh 7502 
        else:
7503 
          iprot.skip(ftype)
7504 
      elif fid == 4:
3064 chandransh 7505 
        if ftype == TType.LIST:
7506 
          self.statuses = []
4133 chandransh 7507 
          (_etype94, _size91) = iprot.readListBegin()
7508 
          for _i95 in xrange(_size91):
7509 
            _elem96 = iprot.readI32();
7510 
            self.statuses.append(_elem96)
3064 chandransh 7511 
          iprot.readListEnd()
2783 chandransh 7512 
        else:
7513 
          iprot.skip(ftype)
1149 chandransh 7514 
      else:
7515 
        iprot.skip(ftype)
7516 
      iprot.readFieldEnd()
7517 
    iprot.readStructEnd()
7518 
 
7519 
  def write(self, oprot):
7520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7522 
      return
3064 chandransh 7523 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7524 
    if self.customerId is not None:
3064 chandransh 7525 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7526 
      oprot.writeI64(self.customerId)
1149 chandransh 7527 
      oprot.writeFieldEnd()
3431 rajveer 7528 
    if self.from_date is not None:
3064 chandransh 7529 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7530 
      oprot.writeI64(self.from_date)
1149 chandransh 7531 
      oprot.writeFieldEnd()
3431 rajveer 7532 
    if self.to_date is not None:
3064 chandransh 7533 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7534 
      oprot.writeI64(self.to_date)
2783 chandransh 7535 
      oprot.writeFieldEnd()
3431 rajveer 7536 
    if self.statuses is not None:
3064 chandransh 7537 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7538 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7539 
      for iter97 in self.statuses:
7540 
        oprot.writeI32(iter97)
3064 chandransh 7541 
      oprot.writeListEnd()
2783 chandransh 7542 
      oprot.writeFieldEnd()
1149 chandransh 7543 
    oprot.writeFieldStop()
7544 
    oprot.writeStructEnd()
7545 
 
3431 rajveer 7546 
  def validate(self):
7547 
    return
7548 
 
7549 
 
1149 chandransh 7550 
  def __repr__(self):
7551 
    L = ['%s=%r' % (key, value)
7552 
      for key, value in self.__dict__.iteritems()]
7553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7554 
 
7555 
  def __eq__(self, other):
7556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7557 
 
7558 
  def __ne__(self, other):
7559 
    return not (self == other)
7560 
 
3064 chandransh 7561 
class getOrdersForCustomer_result:
1149 chandransh 7562 
  """
7563 
  Attributes:
7564 
   - success
7565 
   - ex
7566 
  """
7567 
 
7568 
  thrift_spec = (
3064 chandransh 7569 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7571 
  )
7572 
 
7573 
  def __init__(self, success=None, ex=None,):
7574 
    self.success = success
7575 
    self.ex = ex
7576 
 
7577 
  def read(self, iprot):
7578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7580 
      return
7581 
    iprot.readStructBegin()
7582 
    while True:
7583 
      (fname, ftype, fid) = iprot.readFieldBegin()
7584 
      if ftype == TType.STOP:
7585 
        break
7586 
      if fid == 0:
3064 chandransh 7587 
        if ftype == TType.LIST:
7588 
          self.success = []
4133 chandransh 7589 
          (_etype101, _size98) = iprot.readListBegin()
7590 
          for _i102 in xrange(_size98):
7591 
            _elem103 = Order()
7592 
            _elem103.read(iprot)
7593 
            self.success.append(_elem103)
3064 chandransh 7594 
          iprot.readListEnd()
1149 chandransh 7595 
        else:
7596 
          iprot.skip(ftype)
7597 
      elif fid == 1:
7598 
        if ftype == TType.STRUCT:
7599 
          self.ex = TransactionServiceException()
7600 
          self.ex.read(iprot)
7601 
        else:
7602 
          iprot.skip(ftype)
7603 
      else:
7604 
        iprot.skip(ftype)
7605 
      iprot.readFieldEnd()
7606 
    iprot.readStructEnd()
7607 
 
7608 
  def write(self, oprot):
7609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7611 
      return
3064 chandransh 7612 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7613 
    if self.success is not None:
3064 chandransh 7614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7615 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7616 
      for iter104 in self.success:
7617 
        iter104.write(oprot)
3064 chandransh 7618 
      oprot.writeListEnd()
1149 chandransh 7619 
      oprot.writeFieldEnd()
3431 rajveer 7620 
    if self.ex is not None:
1149 chandransh 7621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7622 
      self.ex.write(oprot)
7623 
      oprot.writeFieldEnd()
7624 
    oprot.writeFieldStop()
7625 
    oprot.writeStructEnd()
7626 
 
3431 rajveer 7627 
  def validate(self):
7628 
    return
7629 
 
7630 
 
1149 chandransh 7631 
  def __repr__(self):
7632 
    L = ['%s=%r' % (key, value)
7633 
      for key, value in self.__dict__.iteritems()]
7634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7635 
 
7636 
  def __eq__(self, other):
7637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7638 
 
7639 
  def __ne__(self, other):
7640 
    return not (self == other)
7641 
 
3064 chandransh 7642 
class createOrder_args:
921 rajveer 7643 
  """
7644 
  Attributes:
3064 chandransh 7645 
   - order
921 rajveer 7646 
  """
7647 
 
7648 
  thrift_spec = (
7649 
    None, # 0
3064 chandransh 7650 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7651 
  )
7652 
 
3064 chandransh 7653 
  def __init__(self, order=None,):
7654 
    self.order = order
921 rajveer 7655 
 
7656 
  def read(self, iprot):
7657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7659 
      return
7660 
    iprot.readStructBegin()
7661 
    while True:
7662 
      (fname, ftype, fid) = iprot.readFieldBegin()
7663 
      if ftype == TType.STOP:
7664 
        break
7665 
      if fid == 1:
3064 chandransh 7666 
        if ftype == TType.STRUCT:
7667 
          self.order = Order()
7668 
          self.order.read(iprot)
921 rajveer 7669 
        else:
7670 
          iprot.skip(ftype)
7671 
      else:
7672 
        iprot.skip(ftype)
7673 
      iprot.readFieldEnd()
7674 
    iprot.readStructEnd()
7675 
 
7676 
  def write(self, oprot):
7677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7679 
      return
3064 chandransh 7680 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7681 
    if self.order is not None:
3064 chandransh 7682 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7683 
      self.order.write(oprot)
921 rajveer 7684 
      oprot.writeFieldEnd()
7685 
    oprot.writeFieldStop()
7686 
    oprot.writeStructEnd()
7687 
 
3431 rajveer 7688 
  def validate(self):
7689 
    return
7690 
 
7691 
 
921 rajveer 7692 
  def __repr__(self):
7693 
    L = ['%s=%r' % (key, value)
7694 
      for key, value in self.__dict__.iteritems()]
7695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7696 
 
7697 
  def __eq__(self, other):
7698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7699 
 
7700 
  def __ne__(self, other):
7701 
    return not (self == other)
7702 
 
3064 chandransh 7703 
class createOrder_result:
921 rajveer 7704 
  """
7705 
  Attributes:
7706 
   - success
7707 
   - ex
7708 
  """
7709 
 
7710 
  thrift_spec = (
3064 chandransh 7711 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7713 
  )
7714 
 
7715 
  def __init__(self, success=None, ex=None,):
7716 
    self.success = success
7717 
    self.ex = ex
7718 
 
7719 
  def read(self, iprot):
7720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7722 
      return
7723 
    iprot.readStructBegin()
7724 
    while True:
7725 
      (fname, ftype, fid) = iprot.readFieldBegin()
7726 
      if ftype == TType.STOP:
7727 
        break
7728 
      if fid == 0:
3064 chandransh 7729 
        if ftype == TType.I64:
7730 
          self.success = iprot.readI64();
921 rajveer 7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      elif fid == 1:
7734 
        if ftype == TType.STRUCT:
7735 
          self.ex = TransactionServiceException()
7736 
          self.ex.read(iprot)
7737 
        else:
7738 
          iprot.skip(ftype)
7739 
      else:
7740 
        iprot.skip(ftype)
7741 
      iprot.readFieldEnd()
7742 
    iprot.readStructEnd()
7743 
 
7744 
  def write(self, oprot):
7745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7747 
      return
3064 chandransh 7748 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7749 
    if self.success is not None:
3064 chandransh 7750 
      oprot.writeFieldBegin('success', TType.I64, 0)
7751 
      oprot.writeI64(self.success)
921 rajveer 7752 
      oprot.writeFieldEnd()
3431 rajveer 7753 
    if self.ex is not None:
921 rajveer 7754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7755 
      self.ex.write(oprot)
7756 
      oprot.writeFieldEnd()
7757 
    oprot.writeFieldStop()
7758 
    oprot.writeStructEnd()
7759 
 
3431 rajveer 7760 
  def validate(self):
7761 
    return
7762 
 
7763 
 
921 rajveer 7764 
  def __repr__(self):
7765 
    L = ['%s=%r' % (key, value)
7766 
      for key, value in self.__dict__.iteritems()]
7767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7768 
 
7769 
  def __eq__(self, other):
7770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7771 
 
7772 
  def __ne__(self, other):
7773 
    return not (self == other)
7774 
 
3064 chandransh 7775 
class getOrder_args:
921 rajveer 7776 
  """
7777 
  Attributes:
3064 chandransh 7778 
   - id
921 rajveer 7779 
  """
7780 
 
7781 
  thrift_spec = (
7782 
    None, # 0
3064 chandransh 7783 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7784 
  )
7785 
 
3064 chandransh 7786 
  def __init__(self, id=None,):
7787 
    self.id = id
921 rajveer 7788 
 
7789 
  def read(self, iprot):
7790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7792 
      return
7793 
    iprot.readStructBegin()
7794 
    while True:
7795 
      (fname, ftype, fid) = iprot.readFieldBegin()
7796 
      if ftype == TType.STOP:
7797 
        break
7798 
      if fid == 1:
7799 
        if ftype == TType.I64:
3064 chandransh 7800 
          self.id = iprot.readI64();
921 rajveer 7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      else:
7804 
        iprot.skip(ftype)
7805 
      iprot.readFieldEnd()
7806 
    iprot.readStructEnd()
7807 
 
7808 
  def write(self, oprot):
7809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7811 
      return
3064 chandransh 7812 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7813 
    if self.id is not None:
3064 chandransh 7814 
      oprot.writeFieldBegin('id', TType.I64, 1)
7815 
      oprot.writeI64(self.id)
921 rajveer 7816 
      oprot.writeFieldEnd()
7817 
    oprot.writeFieldStop()
7818 
    oprot.writeStructEnd()
7819 
 
3431 rajveer 7820 
  def validate(self):
7821 
    return
7822 
 
7823 
 
921 rajveer 7824 
  def __repr__(self):
7825 
    L = ['%s=%r' % (key, value)
7826 
      for key, value in self.__dict__.iteritems()]
7827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7828 
 
7829 
  def __eq__(self, other):
7830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7831 
 
7832 
  def __ne__(self, other):
7833 
    return not (self == other)
7834 
 
3064 chandransh 7835 
class getOrder_result:
921 rajveer 7836 
  """
7837 
  Attributes:
7838 
   - success
7839 
   - ex
7840 
  """
7841 
 
7842 
  thrift_spec = (
3064 chandransh 7843 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7845 
  )
7846 
 
7847 
  def __init__(self, success=None, ex=None,):
7848 
    self.success = success
7849 
    self.ex = ex
7850 
 
7851 
  def read(self, iprot):
7852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7854 
      return
7855 
    iprot.readStructBegin()
7856 
    while True:
7857 
      (fname, ftype, fid) = iprot.readFieldBegin()
7858 
      if ftype == TType.STOP:
7859 
        break
7860 
      if fid == 0:
3064 chandransh 7861 
        if ftype == TType.STRUCT:
7862 
          self.success = Order()
7863 
          self.success.read(iprot)
921 rajveer 7864 
        else:
7865 
          iprot.skip(ftype)
7866 
      elif fid == 1:
7867 
        if ftype == TType.STRUCT:
7868 
          self.ex = TransactionServiceException()
7869 
          self.ex.read(iprot)
7870 
        else:
7871 
          iprot.skip(ftype)
7872 
      else:
7873 
        iprot.skip(ftype)
7874 
      iprot.readFieldEnd()
7875 
    iprot.readStructEnd()
7876 
 
7877 
  def write(self, oprot):
7878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7880 
      return
3064 chandransh 7881 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7882 
    if self.success is not None:
3064 chandransh 7883 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7884 
      self.success.write(oprot)
921 rajveer 7885 
      oprot.writeFieldEnd()
3431 rajveer 7886 
    if self.ex is not None:
921 rajveer 7887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7888 
      self.ex.write(oprot)
7889 
      oprot.writeFieldEnd()
7890 
    oprot.writeFieldStop()
7891 
    oprot.writeStructEnd()
7892 
 
3431 rajveer 7893 
  def validate(self):
7894 
    return
7895 
 
7896 
 
921 rajveer 7897 
  def __repr__(self):
7898 
    L = ['%s=%r' % (key, value)
7899 
      for key, value in self.__dict__.iteritems()]
7900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7901 
 
7902 
  def __eq__(self, other):
7903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7904 
 
7905 
  def __ne__(self, other):
7906 
    return not (self == other)
7907 
 
3064 chandransh 7908 
class getLineItemsForOrder_args:
94 ashish 7909 
  """
7910 
  Attributes:
3064 chandransh 7911 
   - orderId
94 ashish 7912 
  """
7913 
 
7914 
  thrift_spec = (
7915 
    None, # 0
3064 chandransh 7916 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7917 
  )
7918 
 
3064 chandransh 7919 
  def __init__(self, orderId=None,):
7920 
    self.orderId = orderId
94 ashish 7921 
 
7922 
  def read(self, iprot):
7923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7925 
      return
7926 
    iprot.readStructBegin()
7927 
    while True:
7928 
      (fname, ftype, fid) = iprot.readFieldBegin()
7929 
      if ftype == TType.STOP:
7930 
        break
7931 
      if fid == 1:
7932 
        if ftype == TType.I64:
3064 chandransh 7933 
          self.orderId = iprot.readI64();
94 ashish 7934 
        else:
7935 
          iprot.skip(ftype)
7936 
      else:
7937 
        iprot.skip(ftype)
7938 
      iprot.readFieldEnd()
7939 
    iprot.readStructEnd()
7940 
 
7941 
  def write(self, oprot):
7942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7944 
      return
3064 chandransh 7945 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7946 
    if self.orderId is not None:
3064 chandransh 7947 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7948 
      oprot.writeI64(self.orderId)
94 ashish 7949 
      oprot.writeFieldEnd()
7950 
    oprot.writeFieldStop()
7951 
    oprot.writeStructEnd()
7952 
 
3431 rajveer 7953 
  def validate(self):
7954 
    return
7955 
 
7956 
 
94 ashish 7957 
  def __repr__(self):
7958 
    L = ['%s=%r' % (key, value)
7959 
      for key, value in self.__dict__.iteritems()]
7960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7961 
 
7962 
  def __eq__(self, other):
7963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7964 
 
7965 
  def __ne__(self, other):
7966 
    return not (self == other)
7967 
 
3064 chandransh 7968 
class getLineItemsForOrder_result:
94 ashish 7969 
  """
7970 
  Attributes:
7971 
   - success
7972 
   - ex
7973 
  """
7974 
 
7975 
  thrift_spec = (
3064 chandransh 7976 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7978 
  )
7979 
 
7980 
  def __init__(self, success=None, ex=None,):
7981 
    self.success = success
7982 
    self.ex = ex
7983 
 
7984 
  def read(self, iprot):
7985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7987 
      return
7988 
    iprot.readStructBegin()
7989 
    while True:
7990 
      (fname, ftype, fid) = iprot.readFieldBegin()
7991 
      if ftype == TType.STOP:
7992 
        break
7993 
      if fid == 0:
483 rajveer 7994 
        if ftype == TType.LIST:
7995 
          self.success = []
4133 chandransh 7996 
          (_etype108, _size105) = iprot.readListBegin()
7997 
          for _i109 in xrange(_size105):
7998 
            _elem110 = LineItem()
7999 
            _elem110.read(iprot)
8000 
            self.success.append(_elem110)
483 rajveer 8001 
          iprot.readListEnd()
94 ashish 8002 
        else:
8003 
          iprot.skip(ftype)
8004 
      elif fid == 1:
8005 
        if ftype == TType.STRUCT:
8006 
          self.ex = TransactionServiceException()
8007 
          self.ex.read(iprot)
8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      else:
8011 
        iprot.skip(ftype)
8012 
      iprot.readFieldEnd()
8013 
    iprot.readStructEnd()
8014 
 
8015 
  def write(self, oprot):
8016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8018 
      return
3064 chandransh 8019 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8020 
    if self.success is not None:
483 rajveer 8021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8023 
      for iter111 in self.success:
8024 
        iter111.write(oprot)
483 rajveer 8025 
      oprot.writeListEnd()
94 ashish 8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.ex is not None:
94 ashish 8028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8029 
      self.ex.write(oprot)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
94 ashish 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
3064 chandransh 8049 
class getOrderForCustomer_args:
94 ashish 8050 
  """
8051 
  Attributes:
3064 chandransh 8052 
   - orderId
483 rajveer 8053 
   - customerId
94 ashish 8054 
  """
8055 
 
8056 
  thrift_spec = (
8057 
    None, # 0
3064 chandransh 8058 
    (1, TType.I64, 'orderId', None, None, ), # 1
8059 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8060 
  )
8061 
 
3064 chandransh 8062 
  def __init__(self, orderId=None, customerId=None,):
8063 
    self.orderId = orderId
483 rajveer 8064 
    self.customerId = customerId
94 ashish 8065 
 
8066 
  def read(self, iprot):
8067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8069 
      return
8070 
    iprot.readStructBegin()
8071 
    while True:
8072 
      (fname, ftype, fid) = iprot.readFieldBegin()
8073 
      if ftype == TType.STOP:
8074 
        break
8075 
      if fid == 1:
8076 
        if ftype == TType.I64:
3064 chandransh 8077 
          self.orderId = iprot.readI64();
94 ashish 8078 
        else:
8079 
          iprot.skip(ftype)
8080 
      elif fid == 2:
8081 
        if ftype == TType.I64:
3064 chandransh 8082 
          self.customerId = iprot.readI64();
94 ashish 8083 
        else:
8084 
          iprot.skip(ftype)
8085 
      else:
8086 
        iprot.skip(ftype)
8087 
      iprot.readFieldEnd()
8088 
    iprot.readStructEnd()
8089 
 
8090 
  def write(self, oprot):
8091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8093 
      return
3064 chandransh 8094 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8095 
    if self.orderId is not None:
3064 chandransh 8096 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8097 
      oprot.writeI64(self.orderId)
8098 
      oprot.writeFieldEnd()
3431 rajveer 8099 
    if self.customerId is not None:
3064 chandransh 8100 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8101 
      oprot.writeI64(self.customerId)
94 ashish 8102 
      oprot.writeFieldEnd()
8103 
    oprot.writeFieldStop()
8104 
    oprot.writeStructEnd()
8105 
 
3431 rajveer 8106 
  def validate(self):
8107 
    return
8108 
 
8109 
 
94 ashish 8110 
  def __repr__(self):
8111 
    L = ['%s=%r' % (key, value)
8112 
      for key, value in self.__dict__.iteritems()]
8113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8114 
 
8115 
  def __eq__(self, other):
8116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8117 
 
8118 
  def __ne__(self, other):
8119 
    return not (self == other)
8120 
 
3064 chandransh 8121 
class getOrderForCustomer_result:
94 ashish 8122 
  """
8123 
  Attributes:
8124 
   - success
8125 
   - ex
8126 
  """
8127 
 
8128 
  thrift_spec = (
3064 chandransh 8129 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8130 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8131 
  )
8132 
 
8133 
  def __init__(self, success=None, ex=None,):
8134 
    self.success = success
8135 
    self.ex = ex
8136 
 
8137 
  def read(self, iprot):
8138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8140 
      return
8141 
    iprot.readStructBegin()
8142 
    while True:
8143 
      (fname, ftype, fid) = iprot.readFieldBegin()
8144 
      if ftype == TType.STOP:
8145 
        break
8146 
      if fid == 0:
3064 chandransh 8147 
        if ftype == TType.STRUCT:
8148 
          self.success = Order()
8149 
          self.success.read(iprot)
94 ashish 8150 
        else:
8151 
          iprot.skip(ftype)
8152 
      elif fid == 1:
8153 
        if ftype == TType.STRUCT:
8154 
          self.ex = TransactionServiceException()
8155 
          self.ex.read(iprot)
8156 
        else:
8157 
          iprot.skip(ftype)
8158 
      else:
8159 
        iprot.skip(ftype)
8160 
      iprot.readFieldEnd()
8161 
    iprot.readStructEnd()
8162 
 
8163 
  def write(self, oprot):
8164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8166 
      return
3064 chandransh 8167 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8168 
    if self.success is not None:
3064 chandransh 8169 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8170 
      self.success.write(oprot)
94 ashish 8171 
      oprot.writeFieldEnd()
3431 rajveer 8172 
    if self.ex is not None:
94 ashish 8173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8174 
      self.ex.write(oprot)
8175 
      oprot.writeFieldEnd()
8176 
    oprot.writeFieldStop()
8177 
    oprot.writeStructEnd()
8178 
 
3431 rajveer 8179 
  def validate(self):
8180 
    return
8181 
 
8182 
 
94 ashish 8183 
  def __repr__(self):
8184 
    L = ['%s=%r' % (key, value)
8185 
      for key, value in self.__dict__.iteritems()]
8186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8187 
 
8188 
  def __eq__(self, other):
8189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8190 
 
8191 
  def __ne__(self, other):
8192 
    return not (self == other)
8193 
 
3064 chandransh 8194 
class getAlerts_args:
94 ashish 8195 
  """
8196 
  Attributes:
4394 rajveer 8197 
   - type
4444 rajveer 8198 
   - warehouseId
4394 rajveer 8199 
   - status
8200 
   - timestamp
94 ashish 8201 
  """
8202 
 
8203 
  thrift_spec = (
8204 
    None, # 0
4394 rajveer 8205 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8206 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8207 
    (3, TType.I64, 'status', None, None, ), # 3
8208 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8209 
  )
8210 
 
4444 rajveer 8211 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8212 
    self.type = type
4444 rajveer 8213 
    self.warehouseId = warehouseId
4394 rajveer 8214 
    self.status = status
8215 
    self.timestamp = timestamp
94 ashish 8216 
 
8217 
  def read(self, iprot):
8218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8220 
      return
8221 
    iprot.readStructBegin()
8222 
    while True:
8223 
      (fname, ftype, fid) = iprot.readFieldBegin()
8224 
      if ftype == TType.STOP:
8225 
        break
8226 
      if fid == 1:
3064 chandransh 8227 
        if ftype == TType.I64:
4394 rajveer 8228 
          self.type = iprot.readI64();
94 ashish 8229 
        else:
8230 
          iprot.skip(ftype)
3064 chandransh 8231 
      elif fid == 2:
4394 rajveer 8232 
        if ftype == TType.I64:
4444 rajveer 8233 
          self.warehouseId = iprot.readI64();
3064 chandransh 8234 
        else:
8235 
          iprot.skip(ftype)
4394 rajveer 8236 
      elif fid == 3:
8237 
        if ftype == TType.I64:
4444 rajveer 8238 
          self.status = iprot.readI64();
8239 
        else:
8240 
          iprot.skip(ftype)
8241 
      elif fid == 4:
8242 
        if ftype == TType.I64:
4394 rajveer 8243 
          self.timestamp = iprot.readI64();
8244 
        else:
8245 
          iprot.skip(ftype)
94 ashish 8246 
      else:
8247 
        iprot.skip(ftype)
8248 
      iprot.readFieldEnd()
8249 
    iprot.readStructEnd()
8250 
 
8251 
  def write(self, oprot):
8252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8254 
      return
3064 chandransh 8255 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8256 
    if self.type is not None:
8257 
      oprot.writeFieldBegin('type', TType.I64, 1)
8258 
      oprot.writeI64(self.type)
94 ashish 8259 
      oprot.writeFieldEnd()
4444 rajveer 8260 
    if self.warehouseId is not None:
8261 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8262 
      oprot.writeI64(self.warehouseId)
8263 
      oprot.writeFieldEnd()
4394 rajveer 8264 
    if self.status is not None:
4444 rajveer 8265 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8266 
      oprot.writeI64(self.status)
3064 chandransh 8267 
      oprot.writeFieldEnd()
4394 rajveer 8268 
    if self.timestamp is not None:
4444 rajveer 8269 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8270 
      oprot.writeI64(self.timestamp)
8271 
      oprot.writeFieldEnd()
94 ashish 8272 
    oprot.writeFieldStop()
8273 
    oprot.writeStructEnd()
8274 
 
3431 rajveer 8275 
  def validate(self):
8276 
    return
8277 
 
8278 
 
94 ashish 8279 
  def __repr__(self):
8280 
    L = ['%s=%r' % (key, value)
8281 
      for key, value in self.__dict__.iteritems()]
8282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8283 
 
8284 
  def __eq__(self, other):
8285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8286 
 
8287 
  def __ne__(self, other):
8288 
    return not (self == other)
8289 
 
3064 chandransh 8290 
class getAlerts_result:
94 ashish 8291 
  """
8292 
  Attributes:
8293 
   - success
8294 
  """
8295 
 
8296 
  thrift_spec = (
3064 chandransh 8297 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8298 
  )
8299 
 
3064 chandransh 8300 
  def __init__(self, success=None,):
94 ashish 8301 
    self.success = success
8302 
 
8303 
  def read(self, iprot):
8304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8306 
      return
8307 
    iprot.readStructBegin()
8308 
    while True:
8309 
      (fname, ftype, fid) = iprot.readFieldBegin()
8310 
      if ftype == TType.STOP:
8311 
        break
8312 
      if fid == 0:
3064 chandransh 8313 
        if ftype == TType.LIST:
8314 
          self.success = []
4133 chandransh 8315 
          (_etype115, _size112) = iprot.readListBegin()
8316 
          for _i116 in xrange(_size112):
8317 
            _elem117 = Alert()
8318 
            _elem117.read(iprot)
8319 
            self.success.append(_elem117)
3064 chandransh 8320 
          iprot.readListEnd()
94 ashish 8321 
        else:
8322 
          iprot.skip(ftype)
8323 
      else:
8324 
        iprot.skip(ftype)
8325 
      iprot.readFieldEnd()
8326 
    iprot.readStructEnd()
8327 
 
8328 
  def write(self, oprot):
8329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8331 
      return
3064 chandransh 8332 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8333 
    if self.success is not None:
3064 chandransh 8334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8336 
      for iter118 in self.success:
8337 
        iter118.write(oprot)
3064 chandransh 8338 
      oprot.writeListEnd()
94 ashish 8339 
      oprot.writeFieldEnd()
8340 
    oprot.writeFieldStop()
8341 
    oprot.writeStructEnd()
8342 
 
3431 rajveer 8343 
  def validate(self):
8344 
    return
8345 
 
8346 
 
94 ashish 8347 
  def __repr__(self):
8348 
    L = ['%s=%r' % (key, value)
8349 
      for key, value in self.__dict__.iteritems()]
8350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8351 
 
8352 
  def __eq__(self, other):
8353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8354 
 
8355 
  def __ne__(self, other):
8356 
    return not (self == other)
8357 
 
4394 rajveer 8358 
class addAlert_args:
94 ashish 8359 
  """
8360 
  Attributes:
3064 chandransh 8361 
   - type
4444 rajveer 8362 
   - warehouseId
4394 rajveer 8363 
   - description
94 ashish 8364 
  """
8365 
 
8366 
  thrift_spec = (
8367 
    None, # 0
4394 rajveer 8368 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8369 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8370 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8371 
  )
8372 
 
4444 rajveer 8373 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8374 
    self.type = type
4444 rajveer 8375 
    self.warehouseId = warehouseId
4394 rajveer 8376 
    self.description = description
94 ashish 8377 
 
8378 
  def read(self, iprot):
8379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8381 
      return
8382 
    iprot.readStructBegin()
8383 
    while True:
8384 
      (fname, ftype, fid) = iprot.readFieldBegin()
8385 
      if ftype == TType.STOP:
8386 
        break
8387 
      if fid == 1:
8388 
        if ftype == TType.I64:
4394 rajveer 8389 
          self.type = iprot.readI64();
94 ashish 8390 
        else:
8391 
          iprot.skip(ftype)
3064 chandransh 8392 
      elif fid == 2:
4444 rajveer 8393 
        if ftype == TType.I64:
8394 
          self.warehouseId = iprot.readI64();
8395 
        else:
8396 
          iprot.skip(ftype)
8397 
      elif fid == 3:
3064 chandransh 8398 
        if ftype == TType.STRING:
4394 rajveer 8399 
          self.description = iprot.readString();
3064 chandransh 8400 
        else:
8401 
          iprot.skip(ftype)
94 ashish 8402 
      else:
8403 
        iprot.skip(ftype)
8404 
      iprot.readFieldEnd()
8405 
    iprot.readStructEnd()
8406 
 
8407 
  def write(self, oprot):
8408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8410 
      return
4394 rajveer 8411 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8412 
    if self.type is not None:
4394 rajveer 8413 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8414 
      oprot.writeI64(self.type)
8415 
      oprot.writeFieldEnd()
4444 rajveer 8416 
    if self.warehouseId is not None:
8417 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8418 
      oprot.writeI64(self.warehouseId)
8419 
      oprot.writeFieldEnd()
4394 rajveer 8420 
    if self.description is not None:
4444 rajveer 8421 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8422 
      oprot.writeString(self.description)
3064 chandransh 8423 
      oprot.writeFieldEnd()
94 ashish 8424 
    oprot.writeFieldStop()
8425 
    oprot.writeStructEnd()
8426 
 
3431 rajveer 8427 
  def validate(self):
8428 
    return
8429 
 
8430 
 
94 ashish 8431 
  def __repr__(self):
8432 
    L = ['%s=%r' % (key, value)
8433 
      for key, value in self.__dict__.iteritems()]
8434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8435 
 
8436 
  def __eq__(self, other):
8437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8438 
 
8439 
  def __ne__(self, other):
8440 
    return not (self == other)
8441 
 
4394 rajveer 8442 
class addAlert_result:
3064 chandransh 8443 
 
8444 
  thrift_spec = (
8445 
  )
8446 
 
8447 
  def read(self, iprot):
8448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8450 
      return
8451 
    iprot.readStructBegin()
8452 
    while True:
8453 
      (fname, ftype, fid) = iprot.readFieldBegin()
8454 
      if ftype == TType.STOP:
8455 
        break
8456 
      else:
8457 
        iprot.skip(ftype)
8458 
      iprot.readFieldEnd()
8459 
    iprot.readStructEnd()
8460 
 
8461 
  def write(self, oprot):
8462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8464 
      return
4394 rajveer 8465 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8466 
    oprot.writeFieldStop()
8467 
    oprot.writeStructEnd()
8468 
 
3431 rajveer 8469 
  def validate(self):
8470 
    return
8471 
 
8472 
 
3064 chandransh 8473 
  def __repr__(self):
8474 
    L = ['%s=%r' % (key, value)
8475 
      for key, value in self.__dict__.iteritems()]
8476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8477 
 
8478 
  def __eq__(self, other):
8479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8480 
 
8481 
  def __ne__(self, other):
8482 
    return not (self == other)
8483 
 
4444 rajveer 8484 
class markAlertsAsSeen_args:
8485 
  """
8486 
  Attributes:
8487 
   - warehouseId
8488 
  """
8489 
 
8490 
  thrift_spec = (
8491 
    None, # 0
8492 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8493 
  )
8494 
 
8495 
  def __init__(self, warehouseId=None,):
8496 
    self.warehouseId = warehouseId
8497 
 
8498 
  def read(self, iprot):
8499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8501 
      return
8502 
    iprot.readStructBegin()
8503 
    while True:
8504 
      (fname, ftype, fid) = iprot.readFieldBegin()
8505 
      if ftype == TType.STOP:
8506 
        break
8507 
      if fid == 1:
8508 
        if ftype == TType.I64:
8509 
          self.warehouseId = iprot.readI64();
8510 
        else:
8511 
          iprot.skip(ftype)
8512 
      else:
8513 
        iprot.skip(ftype)
8514 
      iprot.readFieldEnd()
8515 
    iprot.readStructEnd()
8516 
 
8517 
  def write(self, oprot):
8518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8520 
      return
8521 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8522 
    if self.warehouseId is not None:
8523 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8524 
      oprot.writeI64(self.warehouseId)
8525 
      oprot.writeFieldEnd()
8526 
    oprot.writeFieldStop()
8527 
    oprot.writeStructEnd()
8528 
 
8529 
  def validate(self):
8530 
    return
8531 
 
8532 
 
8533 
  def __repr__(self):
8534 
    L = ['%s=%r' % (key, value)
8535 
      for key, value in self.__dict__.iteritems()]
8536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8537 
 
8538 
  def __eq__(self, other):
8539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8540 
 
8541 
  def __ne__(self, other):
8542 
    return not (self == other)
8543 
 
8544 
class markAlertsAsSeen_result:
8545 
 
8546 
  thrift_spec = (
8547 
  )
8548 
 
8549 
  def read(self, iprot):
8550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8552 
      return
8553 
    iprot.readStructBegin()
8554 
    while True:
8555 
      (fname, ftype, fid) = iprot.readFieldBegin()
8556 
      if ftype == TType.STOP:
8557 
        break
8558 
      else:
8559 
        iprot.skip(ftype)
8560 
      iprot.readFieldEnd()
8561 
    iprot.readStructEnd()
8562 
 
8563 
  def write(self, oprot):
8564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8566 
      return
8567 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8568 
    oprot.writeFieldStop()
8569 
    oprot.writeStructEnd()
8570 
 
8571 
  def validate(self):
8572 
    return
8573 
 
8574 
 
8575 
  def __repr__(self):
8576 
    L = ['%s=%r' % (key, value)
8577 
      for key, value in self.__dict__.iteritems()]
8578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8579 
 
8580 
  def __eq__(self, other):
8581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8582 
 
8583 
  def __ne__(self, other):
8584 
    return not (self == other)
8585 
 
3064 chandransh 8586 
class getValidOrderCount_args:
8587 
 
8588 
  thrift_spec = (
8589 
  )
8590 
 
8591 
  def read(self, iprot):
8592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8594 
      return
8595 
    iprot.readStructBegin()
8596 
    while True:
8597 
      (fname, ftype, fid) = iprot.readFieldBegin()
8598 
      if ftype == TType.STOP:
8599 
        break
8600 
      else:
8601 
        iprot.skip(ftype)
8602 
      iprot.readFieldEnd()
8603 
    iprot.readStructEnd()
8604 
 
8605 
  def write(self, oprot):
8606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8608 
      return
8609 
    oprot.writeStructBegin('getValidOrderCount_args')
8610 
    oprot.writeFieldStop()
8611 
    oprot.writeStructEnd()
8612 
 
3431 rajveer 8613 
  def validate(self):
8614 
    return
8615 
 
8616 
 
3064 chandransh 8617 
  def __repr__(self):
8618 
    L = ['%s=%r' % (key, value)
8619 
      for key, value in self.__dict__.iteritems()]
8620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8621 
 
8622 
  def __eq__(self, other):
8623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8624 
 
8625 
  def __ne__(self, other):
8626 
    return not (self == other)
8627 
 
8628 
class getValidOrderCount_result:
94 ashish 8629 
  """
8630 
  Attributes:
8631 
   - success
8632 
  """
8633 
 
8634 
  thrift_spec = (
3064 chandransh 8635 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8636 
  )
8637 
 
3064 chandransh 8638 
  def __init__(self, success=None,):
94 ashish 8639 
    self.success = success
8640 
 
8641 
  def read(self, iprot):
8642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8644 
      return
8645 
    iprot.readStructBegin()
8646 
    while True:
8647 
      (fname, ftype, fid) = iprot.readFieldBegin()
8648 
      if ftype == TType.STOP:
8649 
        break
8650 
      if fid == 0:
3064 chandransh 8651 
        if ftype == TType.I64:
8652 
          self.success = iprot.readI64();
94 ashish 8653 
        else:
8654 
          iprot.skip(ftype)
8655 
      else:
8656 
        iprot.skip(ftype)
8657 
      iprot.readFieldEnd()
8658 
    iprot.readStructEnd()
8659 
 
8660 
  def write(self, oprot):
8661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8663 
      return
3064 chandransh 8664 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8665 
    if self.success is not None:
3064 chandransh 8666 
      oprot.writeFieldBegin('success', TType.I64, 0)
8667 
      oprot.writeI64(self.success)
94 ashish 8668 
      oprot.writeFieldEnd()
8669 
    oprot.writeFieldStop()
8670 
    oprot.writeStructEnd()
8671 
 
3431 rajveer 8672 
  def validate(self):
8673 
    return
8674 
 
8675 
 
94 ashish 8676 
  def __repr__(self):
8677 
    L = ['%s=%r' % (key, value)
8678 
      for key, value in self.__dict__.iteritems()]
8679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8680 
 
8681 
  def __eq__(self, other):
8682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8683 
 
8684 
  def __ne__(self, other):
8685 
    return not (self == other)
8686 
 
3064 chandransh 8687 
class getNoOfCustomersWithSuccessfulTransaction_args:
8688 
 
8689 
  thrift_spec = (
8690 
  )
8691 
 
8692 
  def read(self, iprot):
8693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8695 
      return
8696 
    iprot.readStructBegin()
8697 
    while True:
8698 
      (fname, ftype, fid) = iprot.readFieldBegin()
8699 
      if ftype == TType.STOP:
8700 
        break
8701 
      else:
8702 
        iprot.skip(ftype)
8703 
      iprot.readFieldEnd()
8704 
    iprot.readStructEnd()
8705 
 
8706 
  def write(self, oprot):
8707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8709 
      return
8710 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8711 
    oprot.writeFieldStop()
8712 
    oprot.writeStructEnd()
8713 
 
3431 rajveer 8714 
  def validate(self):
8715 
    return
8716 
 
8717 
 
3064 chandransh 8718 
  def __repr__(self):
8719 
    L = ['%s=%r' % (key, value)
8720 
      for key, value in self.__dict__.iteritems()]
8721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8722 
 
8723 
  def __eq__(self, other):
8724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8725 
 
8726 
  def __ne__(self, other):
8727 
    return not (self == other)
8728 
 
8729 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8730 
  """
8731 
  Attributes:
3064 chandransh 8732 
   - success
94 ashish 8733 
  """
8734 
 
8735 
  thrift_spec = (
3064 chandransh 8736 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8737 
  )
8738 
 
3064 chandransh 8739 
  def __init__(self, success=None,):
8740 
    self.success = success
94 ashish 8741 
 
8742 
  def read(self, iprot):
8743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8745 
      return
8746 
    iprot.readStructBegin()
8747 
    while True:
8748 
      (fname, ftype, fid) = iprot.readFieldBegin()
8749 
      if ftype == TType.STOP:
8750 
        break
3064 chandransh 8751 
      if fid == 0:
94 ashish 8752 
        if ftype == TType.I64:
3064 chandransh 8753 
          self.success = iprot.readI64();
94 ashish 8754 
        else:
8755 
          iprot.skip(ftype)
8756 
      else:
8757 
        iprot.skip(ftype)
8758 
      iprot.readFieldEnd()
8759 
    iprot.readStructEnd()
8760 
 
8761 
  def write(self, oprot):
8762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8764 
      return
3064 chandransh 8765 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8766 
    if self.success is not None:
3064 chandransh 8767 
      oprot.writeFieldBegin('success', TType.I64, 0)
8768 
      oprot.writeI64(self.success)
94 ashish 8769 
      oprot.writeFieldEnd()
8770 
    oprot.writeFieldStop()
8771 
    oprot.writeStructEnd()
8772 
 
3431 rajveer 8773 
  def validate(self):
8774 
    return
8775 
 
8776 
 
94 ashish 8777 
  def __repr__(self):
8778 
    L = ['%s=%r' % (key, value)
8779 
      for key, value in self.__dict__.iteritems()]
8780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8781 
 
8782 
  def __eq__(self, other):
8783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8784 
 
8785 
  def __ne__(self, other):
8786 
    return not (self == other)
8787 
 
3064 chandransh 8788 
class getValidOrdersAmountRange_args:
8789 
 
8790 
  thrift_spec = (
8791 
  )
8792 
 
8793 
  def read(self, iprot):
8794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8796 
      return
8797 
    iprot.readStructBegin()
8798 
    while True:
8799 
      (fname, ftype, fid) = iprot.readFieldBegin()
8800 
      if ftype == TType.STOP:
8801 
        break
8802 
      else:
8803 
        iprot.skip(ftype)
8804 
      iprot.readFieldEnd()
8805 
    iprot.readStructEnd()
8806 
 
8807 
  def write(self, oprot):
8808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8810 
      return
8811 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8812 
    oprot.writeFieldStop()
8813 
    oprot.writeStructEnd()
8814 
 
3431 rajveer 8815 
  def validate(self):
8816 
    return
8817 
 
8818 
 
3064 chandransh 8819 
  def __repr__(self):
8820 
    L = ['%s=%r' % (key, value)
8821 
      for key, value in self.__dict__.iteritems()]
8822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8823 
 
8824 
  def __eq__(self, other):
8825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8826 
 
8827 
  def __ne__(self, other):
8828 
    return not (self == other)
8829 
 
8830 
class getValidOrdersAmountRange_result:
94 ashish 8831 
  """
8832 
  Attributes:
8833 
   - success
8834 
  """
8835 
 
8836 
  thrift_spec = (
3064 chandransh 8837 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8838 
  )
8839 
 
3064 chandransh 8840 
  def __init__(self, success=None,):
94 ashish 8841 
    self.success = success
8842 
 
8843 
  def read(self, iprot):
8844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8846 
      return
8847 
    iprot.readStructBegin()
8848 
    while True:
8849 
      (fname, ftype, fid) = iprot.readFieldBegin()
8850 
      if ftype == TType.STOP:
8851 
        break
8852 
      if fid == 0:
483 rajveer 8853 
        if ftype == TType.LIST:
8854 
          self.success = []
4133 chandransh 8855 
          (_etype122, _size119) = iprot.readListBegin()
8856 
          for _i123 in xrange(_size119):
8857 
            _elem124 = iprot.readDouble();
8858 
            self.success.append(_elem124)
483 rajveer 8859 
          iprot.readListEnd()
94 ashish 8860 
        else:
8861 
          iprot.skip(ftype)
8862 
      else:
8863 
        iprot.skip(ftype)
8864 
      iprot.readFieldEnd()
8865 
    iprot.readStructEnd()
8866 
 
8867 
  def write(self, oprot):
8868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8870 
      return
3064 chandransh 8871 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8872 
    if self.success is not None:
483 rajveer 8873 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8874 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8875 
      for iter125 in self.success:
8876 
        oprot.writeDouble(iter125)
483 rajveer 8877 
      oprot.writeListEnd()
94 ashish 8878 
      oprot.writeFieldEnd()
8879 
    oprot.writeFieldStop()
8880 
    oprot.writeStructEnd()
8881 
 
3431 rajveer 8882 
  def validate(self):
8883 
    return
8884 
 
8885 
 
94 ashish 8886 
  def __repr__(self):
8887 
    L = ['%s=%r' % (key, value)
8888 
      for key, value in self.__dict__.iteritems()]
8889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8890 
 
8891 
  def __eq__(self, other):
8892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8893 
 
8894 
  def __ne__(self, other):
8895 
    return not (self == other)
8896 
 
3064 chandransh 8897 
class getValidOrders_args:
1528 ankur.sing 8898 
  """
8899 
  Attributes:
3064 chandransh 8900 
   - limit
1528 ankur.sing 8901 
  """
8902 
 
8903 
  thrift_spec = (
8904 
    None, # 0
3064 chandransh 8905 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8906 
  )
8907 
 
3064 chandransh 8908 
  def __init__(self, limit=None,):
8909 
    self.limit = limit
1528 ankur.sing 8910 
 
8911 
  def read(self, iprot):
8912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8914 
      return
8915 
    iprot.readStructBegin()
8916 
    while True:
8917 
      (fname, ftype, fid) = iprot.readFieldBegin()
8918 
      if ftype == TType.STOP:
8919 
        break
8920 
      if fid == 1:
8921 
        if ftype == TType.I64:
3064 chandransh 8922 
          self.limit = iprot.readI64();
1528 ankur.sing 8923 
        else:
8924 
          iprot.skip(ftype)
8925 
      else:
8926 
        iprot.skip(ftype)
8927 
      iprot.readFieldEnd()
8928 
    iprot.readStructEnd()
8929 
 
8930 
  def write(self, oprot):
8931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8933 
      return
3064 chandransh 8934 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8935 
    if self.limit is not None:
3064 chandransh 8936 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8937 
      oprot.writeI64(self.limit)
1528 ankur.sing 8938 
      oprot.writeFieldEnd()
8939 
    oprot.writeFieldStop()
8940 
    oprot.writeStructEnd()
8941 
 
3431 rajveer 8942 
  def validate(self):
8943 
    return
8944 
 
8945 
 
1528 ankur.sing 8946 
  def __repr__(self):
8947 
    L = ['%s=%r' % (key, value)
8948 
      for key, value in self.__dict__.iteritems()]
8949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8950 
 
8951 
  def __eq__(self, other):
8952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8953 
 
8954 
  def __ne__(self, other):
8955 
    return not (self == other)
8956 
 
3064 chandransh 8957 
class getValidOrders_result:
1528 ankur.sing 8958 
  """
8959 
  Attributes:
8960 
   - success
8961 
  """
8962 
 
8963 
  thrift_spec = (
3064 chandransh 8964 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8965 
  )
8966 
 
3064 chandransh 8967 
  def __init__(self, success=None,):
1528 ankur.sing 8968 
    self.success = success
8969 
 
8970 
  def read(self, iprot):
8971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8973 
      return
8974 
    iprot.readStructBegin()
8975 
    while True:
8976 
      (fname, ftype, fid) = iprot.readFieldBegin()
8977 
      if ftype == TType.STOP:
8978 
        break
8979 
      if fid == 0:
3064 chandransh 8980 
        if ftype == TType.LIST:
8981 
          self.success = []
4133 chandransh 8982 
          (_etype129, _size126) = iprot.readListBegin()
8983 
          for _i130 in xrange(_size126):
8984 
            _elem131 = Order()
8985 
            _elem131.read(iprot)
8986 
            self.success.append(_elem131)
3064 chandransh 8987 
          iprot.readListEnd()
1528 ankur.sing 8988 
        else:
8989 
          iprot.skip(ftype)
8990 
      else:
8991 
        iprot.skip(ftype)
8992 
      iprot.readFieldEnd()
8993 
    iprot.readStructEnd()
8994 
 
8995 
  def write(self, oprot):
8996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8998 
      return
3064 chandransh 8999 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9000 
    if self.success is not None:
3064 chandransh 9001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9003 
      for iter132 in self.success:
9004 
        iter132.write(oprot)
3064 chandransh 9005 
      oprot.writeListEnd()
1528 ankur.sing 9006 
      oprot.writeFieldEnd()
9007 
    oprot.writeFieldStop()
9008 
    oprot.writeStructEnd()
9009 
 
3431 rajveer 9010 
  def validate(self):
9011 
    return
9012 
 
9013 
 
1528 ankur.sing 9014 
  def __repr__(self):
9015 
    L = ['%s=%r' % (key, value)
9016 
      for key, value in self.__dict__.iteritems()]
9017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9018 
 
9019 
  def __eq__(self, other):
9020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9021 
 
9022 
  def __ne__(self, other):
9023 
    return not (self == other)
9024 
 
1220 chandransh 9025 
class batchOrders_args:
9026 
  """
9027 
  Attributes:
9028 
   - warehouseId
9029 
  """
9030 
 
9031 
  thrift_spec = (
9032 
    None, # 0
9033 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9034 
  )
9035 
 
9036 
  def __init__(self, warehouseId=None,):
9037 
    self.warehouseId = warehouseId
9038 
 
9039 
  def read(self, iprot):
9040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9042 
      return
9043 
    iprot.readStructBegin()
9044 
    while True:
9045 
      (fname, ftype, fid) = iprot.readFieldBegin()
9046 
      if ftype == TType.STOP:
9047 
        break
9048 
      if fid == 1:
9049 
        if ftype == TType.I64:
9050 
          self.warehouseId = iprot.readI64();
9051 
        else:
9052 
          iprot.skip(ftype)
9053 
      else:
9054 
        iprot.skip(ftype)
9055 
      iprot.readFieldEnd()
9056 
    iprot.readStructEnd()
9057 
 
9058 
  def write(self, oprot):
9059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9061 
      return
9062 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9063 
    if self.warehouseId is not None:
1220 chandransh 9064 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9065 
      oprot.writeI64(self.warehouseId)
9066 
      oprot.writeFieldEnd()
9067 
    oprot.writeFieldStop()
9068 
    oprot.writeStructEnd()
9069 
 
3431 rajveer 9070 
  def validate(self):
9071 
    return
9072 
 
9073 
 
1220 chandransh 9074 
  def __repr__(self):
9075 
    L = ['%s=%r' % (key, value)
9076 
      for key, value in self.__dict__.iteritems()]
9077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9078 
 
9079 
  def __eq__(self, other):
9080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9081 
 
9082 
  def __ne__(self, other):
9083 
    return not (self == other)
9084 
 
9085 
class batchOrders_result:
9086 
  """
9087 
  Attributes:
9088 
   - success
9089 
   - ex
9090 
  """
9091 
 
9092 
  thrift_spec = (
9093 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9095 
  )
9096 
 
9097 
  def __init__(self, success=None, ex=None,):
9098 
    self.success = success
9099 
    self.ex = ex
9100 
 
9101 
  def read(self, iprot):
9102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9104 
      return
9105 
    iprot.readStructBegin()
9106 
    while True:
9107 
      (fname, ftype, fid) = iprot.readFieldBegin()
9108 
      if ftype == TType.STOP:
9109 
        break
9110 
      if fid == 0:
9111 
        if ftype == TType.LIST:
9112 
          self.success = []
4133 chandransh 9113 
          (_etype136, _size133) = iprot.readListBegin()
9114 
          for _i137 in xrange(_size133):
9115 
            _elem138 = Order()
9116 
            _elem138.read(iprot)
9117 
            self.success.append(_elem138)
1220 chandransh 9118 
          iprot.readListEnd()
9119 
        else:
9120 
          iprot.skip(ftype)
9121 
      elif fid == 1:
9122 
        if ftype == TType.STRUCT:
9123 
          self.ex = TransactionServiceException()
9124 
          self.ex.read(iprot)
9125 
        else:
9126 
          iprot.skip(ftype)
9127 
      else:
9128 
        iprot.skip(ftype)
9129 
      iprot.readFieldEnd()
9130 
    iprot.readStructEnd()
9131 
 
9132 
  def write(self, oprot):
9133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9135 
      return
9136 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9137 
    if self.success is not None:
1220 chandransh 9138 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9139 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9140 
      for iter139 in self.success:
9141 
        iter139.write(oprot)
1220 chandransh 9142 
      oprot.writeListEnd()
9143 
      oprot.writeFieldEnd()
3431 rajveer 9144 
    if self.ex is not None:
1220 chandransh 9145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9146 
      self.ex.write(oprot)
9147 
      oprot.writeFieldEnd()
9148 
    oprot.writeFieldStop()
9149 
    oprot.writeStructEnd()
9150 
 
3431 rajveer 9151 
  def validate(self):
9152 
    return
9153 
 
9154 
 
1220 chandransh 9155 
  def __repr__(self):
9156 
    L = ['%s=%r' % (key, value)
9157 
      for key, value in self.__dict__.iteritems()]
9158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9159 
 
9160 
  def __eq__(self, other):
9161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9162 
 
9163 
  def __ne__(self, other):
9164 
    return not (self == other)
9165 
 
1208 chandransh 9166 
class markOrderAsOutOfStock_args:
9167 
  """
9168 
  Attributes:
9169 
   - orderId
9170 
  """
9171 
 
9172 
  thrift_spec = (
9173 
    None, # 0
9174 
    (1, TType.I64, 'orderId', None, None, ), # 1
9175 
  )
9176 
 
9177 
  def __init__(self, orderId=None,):
9178 
    self.orderId = orderId
9179 
 
9180 
  def read(self, iprot):
9181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9183 
      return
9184 
    iprot.readStructBegin()
9185 
    while True:
9186 
      (fname, ftype, fid) = iprot.readFieldBegin()
9187 
      if ftype == TType.STOP:
9188 
        break
9189 
      if fid == 1:
9190 
        if ftype == TType.I64:
9191 
          self.orderId = iprot.readI64();
9192 
        else:
9193 
          iprot.skip(ftype)
9194 
      else:
9195 
        iprot.skip(ftype)
9196 
      iprot.readFieldEnd()
9197 
    iprot.readStructEnd()
9198 
 
9199 
  def write(self, oprot):
9200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9202 
      return
9203 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9204 
    if self.orderId is not None:
1208 chandransh 9205 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9206 
      oprot.writeI64(self.orderId)
9207 
      oprot.writeFieldEnd()
9208 
    oprot.writeFieldStop()
9209 
    oprot.writeStructEnd()
9210 
 
3431 rajveer 9211 
  def validate(self):
9212 
    return
9213 
 
9214 
 
1208 chandransh 9215 
  def __repr__(self):
9216 
    L = ['%s=%r' % (key, value)
9217 
      for key, value in self.__dict__.iteritems()]
9218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9219 
 
9220 
  def __eq__(self, other):
9221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9222 
 
9223 
  def __ne__(self, other):
9224 
    return not (self == other)
9225 
 
9226 
class markOrderAsOutOfStock_result:
9227 
  """
9228 
  Attributes:
9229 
   - success
9230 
   - ex
9231 
  """
9232 
 
9233 
  thrift_spec = (
9234 
    (0, TType.BOOL, 'success', None, None, ), # 0
9235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9236 
  )
9237 
 
9238 
  def __init__(self, success=None, ex=None,):
9239 
    self.success = success
9240 
    self.ex = ex
9241 
 
9242 
  def read(self, iprot):
9243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9245 
      return
9246 
    iprot.readStructBegin()
9247 
    while True:
9248 
      (fname, ftype, fid) = iprot.readFieldBegin()
9249 
      if ftype == TType.STOP:
9250 
        break
9251 
      if fid == 0:
9252 
        if ftype == TType.BOOL:
9253 
          self.success = iprot.readBool();
9254 
        else:
9255 
          iprot.skip(ftype)
9256 
      elif fid == 1:
9257 
        if ftype == TType.STRUCT:
9258 
          self.ex = TransactionServiceException()
9259 
          self.ex.read(iprot)
9260 
        else:
9261 
          iprot.skip(ftype)
9262 
      else:
9263 
        iprot.skip(ftype)
9264 
      iprot.readFieldEnd()
9265 
    iprot.readStructEnd()
9266 
 
9267 
  def write(self, oprot):
9268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9270 
      return
9271 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9272 
    if self.success is not None:
1208 chandransh 9273 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9274 
      oprot.writeBool(self.success)
9275 
      oprot.writeFieldEnd()
3431 rajveer 9276 
    if self.ex is not None:
1208 chandransh 9277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9278 
      self.ex.write(oprot)
9279 
      oprot.writeFieldEnd()
9280 
    oprot.writeFieldStop()
9281 
    oprot.writeStructEnd()
9282 
 
3431 rajveer 9283 
  def validate(self):
9284 
    return
9285 
 
9286 
 
1208 chandransh 9287 
  def __repr__(self):
9288 
    L = ['%s=%r' % (key, value)
9289 
      for key, value in self.__dict__.iteritems()]
9290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9291 
 
9292 
  def __eq__(self, other):
9293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9294 
 
9295 
  def __ne__(self, other):
9296 
    return not (self == other)
9297 
 
3064 chandransh 9298 
class verifyOrder_args:
759 chandransh 9299 
  """
9300 
  Attributes:
3064 chandransh 9301 
   - orderId
759 chandransh 9302 
  """
9303 
 
9304 
  thrift_spec = (
9305 
    None, # 0
3064 chandransh 9306 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9307 
  )
9308 
 
3064 chandransh 9309 
  def __init__(self, orderId=None,):
9310 
    self.orderId = orderId
759 chandransh 9311 
 
9312 
  def read(self, iprot):
9313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9315 
      return
9316 
    iprot.readStructBegin()
9317 
    while True:
9318 
      (fname, ftype, fid) = iprot.readFieldBegin()
9319 
      if ftype == TType.STOP:
9320 
        break
9321 
      if fid == 1:
9322 
        if ftype == TType.I64:
3064 chandransh 9323 
          self.orderId = iprot.readI64();
759 chandransh 9324 
        else:
9325 
          iprot.skip(ftype)
9326 
      else:
9327 
        iprot.skip(ftype)
9328 
      iprot.readFieldEnd()
9329 
    iprot.readStructEnd()
9330 
 
9331 
  def write(self, oprot):
9332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9334 
      return
3064 chandransh 9335 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9336 
    if self.orderId is not None:
3064 chandransh 9337 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9338 
      oprot.writeI64(self.orderId)
759 chandransh 9339 
      oprot.writeFieldEnd()
9340 
    oprot.writeFieldStop()
9341 
    oprot.writeStructEnd()
9342 
 
3431 rajveer 9343 
  def validate(self):
9344 
    return
9345 
 
9346 
 
759 chandransh 9347 
  def __repr__(self):
9348 
    L = ['%s=%r' % (key, value)
9349 
      for key, value in self.__dict__.iteritems()]
9350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9351 
 
9352 
  def __eq__(self, other):
9353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9354 
 
9355 
  def __ne__(self, other):
9356 
    return not (self == other)
9357 
 
3064 chandransh 9358 
class verifyOrder_result:
759 chandransh 9359 
  """
9360 
  Attributes:
9361 
   - success
9362 
   - ex
9363 
  """
9364 
 
9365 
  thrift_spec = (
9366 
    (0, TType.BOOL, 'success', None, None, ), # 0
9367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9368 
  )
9369 
 
9370 
  def __init__(self, success=None, ex=None,):
9371 
    self.success = success
9372 
    self.ex = ex
9373 
 
9374 
  def read(self, iprot):
9375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9377 
      return
9378 
    iprot.readStructBegin()
9379 
    while True:
9380 
      (fname, ftype, fid) = iprot.readFieldBegin()
9381 
      if ftype == TType.STOP:
9382 
        break
9383 
      if fid == 0:
9384 
        if ftype == TType.BOOL:
9385 
          self.success = iprot.readBool();
9386 
        else:
9387 
          iprot.skip(ftype)
9388 
      elif fid == 1:
9389 
        if ftype == TType.STRUCT:
9390 
          self.ex = TransactionServiceException()
9391 
          self.ex.read(iprot)
9392 
        else:
9393 
          iprot.skip(ftype)
9394 
      else:
9395 
        iprot.skip(ftype)
9396 
      iprot.readFieldEnd()
9397 
    iprot.readStructEnd()
9398 
 
9399 
  def write(self, oprot):
9400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9402 
      return
3064 chandransh 9403 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9404 
    if self.success is not None:
759 chandransh 9405 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9406 
      oprot.writeBool(self.success)
9407 
      oprot.writeFieldEnd()
3431 rajveer 9408 
    if self.ex is not None:
759 chandransh 9409 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9410 
      self.ex.write(oprot)
9411 
      oprot.writeFieldEnd()
9412 
    oprot.writeFieldStop()
9413 
    oprot.writeStructEnd()
9414 
 
3431 rajveer 9415 
  def validate(self):
9416 
    return
9417 
 
9418 
 
759 chandransh 9419 
  def __repr__(self):
9420 
    L = ['%s=%r' % (key, value)
9421 
      for key, value in self.__dict__.iteritems()]
9422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9423 
 
9424 
  def __eq__(self, other):
9425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9426 
 
9427 
  def __ne__(self, other):
9428 
    return not (self == other)
9429 
 
3064 chandransh 9430 
class acceptOrder_args:
1113 chandransh 9431 
  """
9432 
  Attributes:
3064 chandransh 9433 
   - orderId
1113 chandransh 9434 
  """
9435 
 
9436 
  thrift_spec = (
9437 
    None, # 0
3064 chandransh 9438 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9439 
  )
9440 
 
3064 chandransh 9441 
  def __init__(self, orderId=None,):
9442 
    self.orderId = orderId
1113 chandransh 9443 
 
9444 
  def read(self, iprot):
9445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9447 
      return
9448 
    iprot.readStructBegin()
9449 
    while True:
9450 
      (fname, ftype, fid) = iprot.readFieldBegin()
9451 
      if ftype == TType.STOP:
9452 
        break
9453 
      if fid == 1:
9454 
        if ftype == TType.I64:
3064 chandransh 9455 
          self.orderId = iprot.readI64();
1113 chandransh 9456 
        else:
9457 
          iprot.skip(ftype)
9458 
      else:
9459 
        iprot.skip(ftype)
9460 
      iprot.readFieldEnd()
9461 
    iprot.readStructEnd()
9462 
 
9463 
  def write(self, oprot):
9464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9466 
      return
3064 chandransh 9467 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9468 
    if self.orderId is not None:
3064 chandransh 9469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9470 
      oprot.writeI64(self.orderId)
1113 chandransh 9471 
      oprot.writeFieldEnd()
9472 
    oprot.writeFieldStop()
9473 
    oprot.writeStructEnd()
9474 
 
3431 rajveer 9475 
  def validate(self):
9476 
    return
9477 
 
9478 
 
1113 chandransh 9479 
  def __repr__(self):
9480 
    L = ['%s=%r' % (key, value)
9481 
      for key, value in self.__dict__.iteritems()]
9482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9483 
 
9484 
  def __eq__(self, other):
9485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9486 
 
9487 
  def __ne__(self, other):
9488 
    return not (self == other)
9489 
 
3064 chandransh 9490 
class acceptOrder_result:
1113 chandransh 9491 
  """
9492 
  Attributes:
9493 
   - success
9494 
   - ex
9495 
  """
9496 
 
9497 
  thrift_spec = (
3064 chandransh 9498 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9500 
  )
9501 
 
9502 
  def __init__(self, success=None, ex=None,):
9503 
    self.success = success
9504 
    self.ex = ex
9505 
 
9506 
  def read(self, iprot):
9507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9509 
      return
9510 
    iprot.readStructBegin()
9511 
    while True:
9512 
      (fname, ftype, fid) = iprot.readFieldBegin()
9513 
      if ftype == TType.STOP:
9514 
        break
9515 
      if fid == 0:
3064 chandransh 9516 
        if ftype == TType.BOOL:
9517 
          self.success = iprot.readBool();
1113 chandransh 9518 
        else:
9519 
          iprot.skip(ftype)
9520 
      elif fid == 1:
9521 
        if ftype == TType.STRUCT:
9522 
          self.ex = TransactionServiceException()
9523 
          self.ex.read(iprot)
9524 
        else:
9525 
          iprot.skip(ftype)
9526 
      else:
9527 
        iprot.skip(ftype)
9528 
      iprot.readFieldEnd()
9529 
    iprot.readStructEnd()
9530 
 
9531 
  def write(self, oprot):
9532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9534 
      return
3064 chandransh 9535 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9536 
    if self.success is not None:
3064 chandransh 9537 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9538 
      oprot.writeBool(self.success)
1113 chandransh 9539 
      oprot.writeFieldEnd()
3431 rajveer 9540 
    if self.ex is not None:
1113 chandransh 9541 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9542 
      self.ex.write(oprot)
9543 
      oprot.writeFieldEnd()
9544 
    oprot.writeFieldStop()
9545 
    oprot.writeStructEnd()
9546 
 
3431 rajveer 9547 
  def validate(self):
9548 
    return
9549 
 
9550 
 
1113 chandransh 9551 
  def __repr__(self):
9552 
    L = ['%s=%r' % (key, value)
9553 
      for key, value in self.__dict__.iteritems()]
9554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9555 
 
9556 
  def __eq__(self, other):
9557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9558 
 
9559 
  def __ne__(self, other):
9560 
    return not (self == other)
9561 
 
3064 chandransh 9562 
class addBillingDetails_args:
1135 chandransh 9563 
  """
9564 
  Attributes:
3064 chandransh 9565 
   - orderId
9566 
   - invoice_number
4283 anupam.sin 9567 
   - imeiNumber
9568 
   - itemNumber
3064 chandransh 9569 
   - billed_by
4264 rajveer 9570 
   - jacketNumber
4283 anupam.sin 9571 
   - billingType
9572 
   - vendorId
1135 chandransh 9573 
  """
9574 
 
9575 
  thrift_spec = (
9576 
    None, # 0
3064 chandransh 9577 
    (1, TType.I64, 'orderId', None, None, ), # 1
9578 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9579 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9580 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9581 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9582 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9583 
    (7, TType.I64, 'billingType', None, None, ), # 7
9584 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9585 
  )
9586 
 
4283 anupam.sin 9587 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9588 
    self.orderId = orderId
9589 
    self.invoice_number = invoice_number
4283 anupam.sin 9590 
    self.imeiNumber = imeiNumber
9591 
    self.itemNumber = itemNumber
3064 chandransh 9592 
    self.billed_by = billed_by
4264 rajveer 9593 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9594 
    self.billingType = billingType
9595 
    self.vendorId = vendorId
1135 chandransh 9596 
 
9597 
  def read(self, iprot):
9598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9600 
      return
9601 
    iprot.readStructBegin()
9602 
    while True:
9603 
      (fname, ftype, fid) = iprot.readFieldBegin()
9604 
      if ftype == TType.STOP:
9605 
        break
9606 
      if fid == 1:
9607 
        if ftype == TType.I64:
3064 chandransh 9608 
          self.orderId = iprot.readI64();
1135 chandransh 9609 
        else:
9610 
          iprot.skip(ftype)
9611 
      elif fid == 2:
3064 chandransh 9612 
        if ftype == TType.STRING:
9613 
          self.invoice_number = iprot.readString();
1135 chandransh 9614 
        else:
9615 
          iprot.skip(ftype)
3064 chandransh 9616 
      elif fid == 3:
4264 rajveer 9617 
        if ftype == TType.I64:
3064 chandransh 9618 
          self.imeiNumber = iprot.readI64();
9619 
        else:
9620 
          iprot.skip(ftype)
9621 
      elif fid == 4:
9622 
        if ftype == TType.STRING:
9623 
          self.itemNumber = iprot.readString();
9624 
        else:
9625 
          iprot.skip(ftype)
9626 
      elif fid == 5:
9627 
        if ftype == TType.STRING:
4283 anupam.sin 9628 
          self.billed_by = iprot.readString();
3064 chandransh 9629 
        else:
9630 
          iprot.skip(ftype)
9631 
      elif fid == 6:
9632 
        if ftype == TType.I64:
4283 anupam.sin 9633 
          self.jacketNumber = iprot.readI64();
9634 
        else:
9635 
          iprot.skip(ftype)
9636 
      elif fid == 7:
9637 
        if ftype == TType.I64:
3064 chandransh 9638 
          self.billingType = iprot.readI64();
9639 
        else:
9640 
          iprot.skip(ftype)
4283 anupam.sin 9641 
      elif fid == 8:
9642 
        if ftype == TType.I64:
9643 
          self.vendorId = iprot.readI64();
9644 
        else:
9645 
          iprot.skip(ftype)
1246 chandransh 9646 
      else:
9647 
        iprot.skip(ftype)
9648 
      iprot.readFieldEnd()
9649 
    iprot.readStructEnd()
9650 
 
9651 
  def write(self, oprot):
9652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9654 
      return
4283 anupam.sin 9655 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9656 
    if self.orderId is not None:
3064 chandransh 9657 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9658 
      oprot.writeI64(self.orderId)
1246 chandransh 9659 
      oprot.writeFieldEnd()
4283 anupam.sin 9660 
    if self.invoice_number is not None:
9661 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9662 
      oprot.writeString(self.invoice_number)
1246 chandransh 9663 
      oprot.writeFieldEnd()
3431 rajveer 9664 
    if self.imeiNumber is not None:
3064 chandransh 9665 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9666 
      oprot.writeI64(self.imeiNumber)
9667 
      oprot.writeFieldEnd()
3431 rajveer 9668 
    if self.itemNumber is not None:
3064 chandransh 9669 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9670 
      oprot.writeString(self.itemNumber)
9671 
      oprot.writeFieldEnd()
4283 anupam.sin 9672 
    if self.billed_by is not None:
9673 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9674 
      oprot.writeString(self.billed_by)
3064 chandransh 9675 
      oprot.writeFieldEnd()
4283 anupam.sin 9676 
    if self.jacketNumber is not None:
9677 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9678 
      oprot.writeI64(self.jacketNumber)
9679 
      oprot.writeFieldEnd()
3431 rajveer 9680 
    if self.billingType is not None:
4283 anupam.sin 9681 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9682 
      oprot.writeI64(self.billingType)
9683 
      oprot.writeFieldEnd()
4283 anupam.sin 9684 
    if self.vendorId is not None:
9685 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9686 
      oprot.writeI64(self.vendorId)
9687 
      oprot.writeFieldEnd()
1246 chandransh 9688 
    oprot.writeFieldStop()
9689 
    oprot.writeStructEnd()
9690 
 
3431 rajveer 9691 
  def validate(self):
9692 
    return
9693 
 
9694 
 
1246 chandransh 9695 
  def __repr__(self):
9696 
    L = ['%s=%r' % (key, value)
9697 
      for key, value in self.__dict__.iteritems()]
9698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9699 
 
9700 
  def __eq__(self, other):
9701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9702 
 
9703 
  def __ne__(self, other):
9704 
    return not (self == other)
9705 
 
4283 anupam.sin 9706 
class addBillingDetails_result:
1246 chandransh 9707 
  """
9708 
  Attributes:
3064 chandransh 9709 
   - success
1246 chandransh 9710 
   - ex
9711 
  """
9712 
 
9713 
  thrift_spec = (
3064 chandransh 9714 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9716 
  )
9717 
 
3064 chandransh 9718 
  def __init__(self, success=None, ex=None,):
9719 
    self.success = success
1246 chandransh 9720 
    self.ex = ex
9721 
 
9722 
  def read(self, iprot):
9723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9725 
      return
9726 
    iprot.readStructBegin()
9727 
    while True:
9728 
      (fname, ftype, fid) = iprot.readFieldBegin()
9729 
      if ftype == TType.STOP:
9730 
        break
3064 chandransh 9731 
      if fid == 0:
9732 
        if ftype == TType.BOOL:
9733 
          self.success = iprot.readBool();
9734 
        else:
9735 
          iprot.skip(ftype)
9736 
      elif fid == 1:
1246 chandransh 9737 
        if ftype == TType.STRUCT:
9738 
          self.ex = TransactionServiceException()
9739 
          self.ex.read(iprot)
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      else:
9743 
        iprot.skip(ftype)
9744 
      iprot.readFieldEnd()
9745 
    iprot.readStructEnd()
9746 
 
9747 
  def write(self, oprot):
9748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9750 
      return
4283 anupam.sin 9751 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9752 
    if self.success is not None:
3064 chandransh 9753 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9754 
      oprot.writeBool(self.success)
9755 
      oprot.writeFieldEnd()
3431 rajveer 9756 
    if self.ex is not None:
1246 chandransh 9757 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9758 
      self.ex.write(oprot)
9759 
      oprot.writeFieldEnd()
9760 
    oprot.writeFieldStop()
9761 
    oprot.writeStructEnd()
9762 
 
3431 rajveer 9763 
  def validate(self):
9764 
    return
9765 
 
9766 
 
1246 chandransh 9767 
  def __repr__(self):
9768 
    L = ['%s=%r' % (key, value)
9769 
      for key, value in self.__dict__.iteritems()]
9770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9771 
 
9772 
  def __eq__(self, other):
9773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9774 
 
9775 
  def __ne__(self, other):
9776 
    return not (self == other)
9777 
 
4579 rajveer 9778 
class addInvoiceNumber_args:
9779 
  """
9780 
  Attributes:
9781 
   - orderId
9782 
   - invoiceNumber
9783 
  """
9784 
 
9785 
  thrift_spec = (
9786 
    None, # 0
9787 
    (1, TType.I64, 'orderId', None, None, ), # 1
9788 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
9789 
  )
9790 
 
9791 
  def __init__(self, orderId=None, invoiceNumber=None,):
9792 
    self.orderId = orderId
9793 
    self.invoiceNumber = invoiceNumber
9794 
 
9795 
  def read(self, iprot):
9796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9798 
      return
9799 
    iprot.readStructBegin()
9800 
    while True:
9801 
      (fname, ftype, fid) = iprot.readFieldBegin()
9802 
      if ftype == TType.STOP:
9803 
        break
9804 
      if fid == 1:
9805 
        if ftype == TType.I64:
9806 
          self.orderId = iprot.readI64();
9807 
        else:
9808 
          iprot.skip(ftype)
9809 
      elif fid == 2:
9810 
        if ftype == TType.STRING:
9811 
          self.invoiceNumber = iprot.readString();
9812 
        else:
9813 
          iprot.skip(ftype)
9814 
      else:
9815 
        iprot.skip(ftype)
9816 
      iprot.readFieldEnd()
9817 
    iprot.readStructEnd()
9818 
 
9819 
  def write(self, oprot):
9820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9822 
      return
9823 
    oprot.writeStructBegin('addInvoiceNumber_args')
9824 
    if self.orderId is not None:
9825 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9826 
      oprot.writeI64(self.orderId)
9827 
      oprot.writeFieldEnd()
9828 
    if self.invoiceNumber is not None:
9829 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
9830 
      oprot.writeString(self.invoiceNumber)
9831 
      oprot.writeFieldEnd()
9832 
    oprot.writeFieldStop()
9833 
    oprot.writeStructEnd()
9834 
 
9835 
  def validate(self):
9836 
    return
9837 
 
9838 
 
9839 
  def __repr__(self):
9840 
    L = ['%s=%r' % (key, value)
9841 
      for key, value in self.__dict__.iteritems()]
9842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9843 
 
9844 
  def __eq__(self, other):
9845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9846 
 
9847 
  def __ne__(self, other):
9848 
    return not (self == other)
9849 
 
9850 
class addInvoiceNumber_result:
9851 
  """
9852 
  Attributes:
9853 
   - ex
9854 
  """
9855 
 
9856 
  thrift_spec = (
9857 
    None, # 0
9858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9859 
  )
9860 
 
9861 
  def __init__(self, ex=None,):
9862 
    self.ex = ex
9863 
 
9864 
  def read(self, iprot):
9865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9867 
      return
9868 
    iprot.readStructBegin()
9869 
    while True:
9870 
      (fname, ftype, fid) = iprot.readFieldBegin()
9871 
      if ftype == TType.STOP:
9872 
        break
9873 
      if fid == 1:
9874 
        if ftype == TType.STRUCT:
9875 
          self.ex = TransactionServiceException()
9876 
          self.ex.read(iprot)
9877 
        else:
9878 
          iprot.skip(ftype)
9879 
      else:
9880 
        iprot.skip(ftype)
9881 
      iprot.readFieldEnd()
9882 
    iprot.readStructEnd()
9883 
 
9884 
  def write(self, oprot):
9885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9887 
      return
9888 
    oprot.writeStructBegin('addInvoiceNumber_result')
9889 
    if self.ex is not None:
9890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9891 
      self.ex.write(oprot)
9892 
      oprot.writeFieldEnd()
9893 
    oprot.writeFieldStop()
9894 
    oprot.writeStructEnd()
9895 
 
9896 
  def validate(self):
9897 
    return
9898 
 
9899 
 
9900 
  def __repr__(self):
9901 
    L = ['%s=%r' % (key, value)
9902 
      for key, value in self.__dict__.iteritems()]
9903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9904 
 
9905 
  def __eq__(self, other):
9906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9907 
 
9908 
  def __ne__(self, other):
9909 
    return not (self == other)
9910 
 
3064 chandransh 9911 
class markOrdersAsManifested_args:
1408 ankur.sing 9912 
  """
9913 
  Attributes:
3064 chandransh 9914 
   - warehouseId
1408 ankur.sing 9915 
   - providerId
3064 chandransh 9916 
   - cod
1408 ankur.sing 9917 
  """
9918 
 
9919 
  thrift_spec = (
9920 
    None, # 0
3064 chandransh 9921 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9922 
    (2, TType.I64, 'providerId', None, None, ), # 2
9923 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9924 
  )
9925 
 
3064 chandransh 9926 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9927 
    self.warehouseId = warehouseId
1408 ankur.sing 9928 
    self.providerId = providerId
3064 chandransh 9929 
    self.cod = cod
1408 ankur.sing 9930 
 
9931 
  def read(self, iprot):
9932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9934 
      return
9935 
    iprot.readStructBegin()
9936 
    while True:
9937 
      (fname, ftype, fid) = iprot.readFieldBegin()
9938 
      if ftype == TType.STOP:
9939 
        break
9940 
      if fid == 1:
9941 
        if ftype == TType.I64:
3064 chandransh 9942 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9943 
        else:
9944 
          iprot.skip(ftype)
9945 
      elif fid == 2:
9946 
        if ftype == TType.I64:
3064 chandransh 9947 
          self.providerId = iprot.readI64();
1408 ankur.sing 9948 
        else:
9949 
          iprot.skip(ftype)
3064 chandransh 9950 
      elif fid == 3:
9951 
        if ftype == TType.BOOL:
9952 
          self.cod = iprot.readBool();
9953 
        else:
9954 
          iprot.skip(ftype)
1408 ankur.sing 9955 
      else:
9956 
        iprot.skip(ftype)
9957 
      iprot.readFieldEnd()
9958 
    iprot.readStructEnd()
9959 
 
9960 
  def write(self, oprot):
9961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9963 
      return
3064 chandransh 9964 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9965 
    if self.warehouseId is not None:
3064 chandransh 9966 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9967 
      oprot.writeI64(self.warehouseId)
9968 
      oprot.writeFieldEnd()
3431 rajveer 9969 
    if self.providerId is not None:
3064 chandransh 9970 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9971 
      oprot.writeI64(self.providerId)
9972 
      oprot.writeFieldEnd()
3431 rajveer 9973 
    if self.cod is not None:
3064 chandransh 9974 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9975 
      oprot.writeBool(self.cod)
1408 ankur.sing 9976 
      oprot.writeFieldEnd()
9977 
    oprot.writeFieldStop()
9978 
    oprot.writeStructEnd()
9979 
 
3431 rajveer 9980 
  def validate(self):
9981 
    return
9982 
 
9983 
 
1408 ankur.sing 9984 
  def __repr__(self):
9985 
    L = ['%s=%r' % (key, value)
9986 
      for key, value in self.__dict__.iteritems()]
9987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9988 
 
9989 
  def __eq__(self, other):
9990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9991 
 
9992 
  def __ne__(self, other):
9993 
    return not (self == other)
9994 
 
3064 chandransh 9995 
class markOrdersAsManifested_result:
1408 ankur.sing 9996 
  """
9997 
  Attributes:
9998 
   - success
3064 chandransh 9999 
   - ex
1408 ankur.sing 10000 
  """
10001 
 
10002 
  thrift_spec = (
3064 chandransh 10003 
    (0, TType.BOOL, 'success', None, None, ), # 0
10004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10005 
  )
10006 
 
3064 chandransh 10007 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10008 
    self.success = success
3064 chandransh 10009 
    self.ex = ex
1408 ankur.sing 10010 
 
10011 
  def read(self, iprot):
10012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10014 
      return
10015 
    iprot.readStructBegin()
10016 
    while True:
10017 
      (fname, ftype, fid) = iprot.readFieldBegin()
10018 
      if ftype == TType.STOP:
10019 
        break
10020 
      if fid == 0:
3064 chandransh 10021 
        if ftype == TType.BOOL:
10022 
          self.success = iprot.readBool();
1408 ankur.sing 10023 
        else:
10024 
          iprot.skip(ftype)
3064 chandransh 10025 
      elif fid == 1:
10026 
        if ftype == TType.STRUCT:
10027 
          self.ex = TransactionServiceException()
10028 
          self.ex.read(iprot)
10029 
        else:
10030 
          iprot.skip(ftype)
1408 ankur.sing 10031 
      else:
10032 
        iprot.skip(ftype)
10033 
      iprot.readFieldEnd()
10034 
    iprot.readStructEnd()
10035 
 
10036 
  def write(self, oprot):
10037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10039 
      return
3064 chandransh 10040 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10041 
    if self.success is not None:
3064 chandransh 10042 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10043 
      oprot.writeBool(self.success)
1408 ankur.sing 10044 
      oprot.writeFieldEnd()
3431 rajveer 10045 
    if self.ex is not None:
3064 chandransh 10046 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10047 
      self.ex.write(oprot)
10048 
      oprot.writeFieldEnd()
1408 ankur.sing 10049 
    oprot.writeFieldStop()
10050 
    oprot.writeStructEnd()
10051 
 
3431 rajveer 10052 
  def validate(self):
10053 
    return
10054 
 
10055 
 
1408 ankur.sing 10056 
  def __repr__(self):
10057 
    L = ['%s=%r' % (key, value)
10058 
      for key, value in self.__dict__.iteritems()]
10059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10060 
 
10061 
  def __eq__(self, other):
10062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10063 
 
10064 
  def __ne__(self, other):
10065 
    return not (self == other)
10066 
 
4410 rajveer 10067 
class markOrdersAsShippedFromWarehouse_args:
10068 
  """
10069 
  Attributes:
10070 
   - warehouseId
10071 
   - providerId
10072 
   - cod
10073 
  """
10074 
 
10075 
  thrift_spec = (
10076 
    None, # 0
10077 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10078 
    (2, TType.I64, 'providerId', None, None, ), # 2
10079 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10080 
  )
10081 
 
10082 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10083 
    self.warehouseId = warehouseId
10084 
    self.providerId = providerId
10085 
    self.cod = cod
10086 
 
10087 
  def read(self, iprot):
10088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10090 
      return
10091 
    iprot.readStructBegin()
10092 
    while True:
10093 
      (fname, ftype, fid) = iprot.readFieldBegin()
10094 
      if ftype == TType.STOP:
10095 
        break
10096 
      if fid == 1:
10097 
        if ftype == TType.I64:
10098 
          self.warehouseId = iprot.readI64();
10099 
        else:
10100 
          iprot.skip(ftype)
10101 
      elif fid == 2:
10102 
        if ftype == TType.I64:
10103 
          self.providerId = iprot.readI64();
10104 
        else:
10105 
          iprot.skip(ftype)
10106 
      elif fid == 3:
10107 
        if ftype == TType.BOOL:
10108 
          self.cod = iprot.readBool();
10109 
        else:
10110 
          iprot.skip(ftype)
10111 
      else:
10112 
        iprot.skip(ftype)
10113 
      iprot.readFieldEnd()
10114 
    iprot.readStructEnd()
10115 
 
10116 
  def write(self, oprot):
10117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10119 
      return
10120 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10121 
    if self.warehouseId is not None:
10122 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10123 
      oprot.writeI64(self.warehouseId)
10124 
      oprot.writeFieldEnd()
10125 
    if self.providerId is not None:
10126 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10127 
      oprot.writeI64(self.providerId)
10128 
      oprot.writeFieldEnd()
10129 
    if self.cod is not None:
10130 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10131 
      oprot.writeBool(self.cod)
10132 
      oprot.writeFieldEnd()
10133 
    oprot.writeFieldStop()
10134 
    oprot.writeStructEnd()
10135 
 
10136 
  def validate(self):
10137 
    return
10138 
 
10139 
 
10140 
  def __repr__(self):
10141 
    L = ['%s=%r' % (key, value)
10142 
      for key, value in self.__dict__.iteritems()]
10143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10144 
 
10145 
  def __eq__(self, other):
10146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10147 
 
10148 
  def __ne__(self, other):
10149 
    return not (self == other)
10150 
 
10151 
class markOrdersAsShippedFromWarehouse_result:
10152 
  """
10153 
  Attributes:
10154 
   - success
10155 
   - ex
10156 
  """
10157 
 
10158 
  thrift_spec = (
10159 
    (0, TType.BOOL, 'success', None, None, ), # 0
10160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10161 
  )
10162 
 
10163 
  def __init__(self, success=None, ex=None,):
10164 
    self.success = success
10165 
    self.ex = ex
10166 
 
10167 
  def read(self, iprot):
10168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10170 
      return
10171 
    iprot.readStructBegin()
10172 
    while True:
10173 
      (fname, ftype, fid) = iprot.readFieldBegin()
10174 
      if ftype == TType.STOP:
10175 
        break
10176 
      if fid == 0:
10177 
        if ftype == TType.BOOL:
10178 
          self.success = iprot.readBool();
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      elif fid == 1:
10182 
        if ftype == TType.STRUCT:
10183 
          self.ex = TransactionServiceException()
10184 
          self.ex.read(iprot)
10185 
        else:
10186 
          iprot.skip(ftype)
10187 
      else:
10188 
        iprot.skip(ftype)
10189 
      iprot.readFieldEnd()
10190 
    iprot.readStructEnd()
10191 
 
10192 
  def write(self, oprot):
10193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10195 
      return
10196 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10197 
    if self.success is not None:
10198 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10199 
      oprot.writeBool(self.success)
10200 
      oprot.writeFieldEnd()
10201 
    if self.ex is not None:
10202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10203 
      self.ex.write(oprot)
10204 
      oprot.writeFieldEnd()
10205 
    oprot.writeFieldStop()
10206 
    oprot.writeStructEnd()
10207 
 
10208 
  def validate(self):
10209 
    return
10210 
 
10211 
 
10212 
  def __repr__(self):
10213 
    L = ['%s=%r' % (key, value)
10214 
      for key, value in self.__dict__.iteritems()]
10215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10216 
 
10217 
  def __eq__(self, other):
10218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10219 
 
10220 
  def __ne__(self, other):
10221 
    return not (self == other)
10222 
 
3064 chandransh 10223 
class markOrdersAsPickedUp_args:
304 ashish 10224 
  """
10225 
  Attributes:
3064 chandransh 10226 
   - providerId
10227 
   - pickupDetails
304 ashish 10228 
  """
94 ashish 10229 
 
304 ashish 10230 
  thrift_spec = (
10231 
    None, # 0
3064 chandransh 10232 
    (1, TType.I64, 'providerId', None, None, ), # 1
10233 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10234 
  )
10235 
 
3064 chandransh 10236 
  def __init__(self, providerId=None, pickupDetails=None,):
10237 
    self.providerId = providerId
10238 
    self.pickupDetails = pickupDetails
304 ashish 10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 1:
10250 
        if ftype == TType.I64:
3064 chandransh 10251 
          self.providerId = iprot.readI64();
304 ashish 10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 2:
3064 chandransh 10255 
        if ftype == TType.MAP:
10256 
          self.pickupDetails = {}
4133 chandransh 10257 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10258 
          for _i144 in xrange(_size140):
10259 
            _key145 = iprot.readString();
10260 
            _val146 = iprot.readString();
10261 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10262 
          iprot.readMapEnd()
304 ashish 10263 
        else:
10264 
          iprot.skip(ftype)
10265 
      else:
10266 
        iprot.skip(ftype)
10267 
      iprot.readFieldEnd()
10268 
    iprot.readStructEnd()
10269 
 
10270 
  def write(self, oprot):
10271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10273 
      return
3064 chandransh 10274 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10275 
    if self.providerId is not None:
3064 chandransh 10276 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10277 
      oprot.writeI64(self.providerId)
304 ashish 10278 
      oprot.writeFieldEnd()
3431 rajveer 10279 
    if self.pickupDetails is not None:
3064 chandransh 10280 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10281 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10282 
      for kiter147,viter148 in self.pickupDetails.items():
10283 
        oprot.writeString(kiter147)
10284 
        oprot.writeString(viter148)
3064 chandransh 10285 
      oprot.writeMapEnd()
304 ashish 10286 
      oprot.writeFieldEnd()
10287 
    oprot.writeFieldStop()
10288 
    oprot.writeStructEnd()
10289 
 
3431 rajveer 10290 
  def validate(self):
10291 
    return
10292 
 
10293 
 
304 ashish 10294 
  def __repr__(self):
10295 
    L = ['%s=%r' % (key, value)
10296 
      for key, value in self.__dict__.iteritems()]
10297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10298 
 
10299 
  def __eq__(self, other):
10300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10301 
 
10302 
  def __ne__(self, other):
10303 
    return not (self == other)
10304 
 
3064 chandransh 10305 
class markOrdersAsPickedUp_result:
304 ashish 10306 
  """
10307 
  Attributes:
10308 
   - success
3064 chandransh 10309 
   - ex
304 ashish 10310 
  """
10311 
 
10312 
  thrift_spec = (
3064 chandransh 10313 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10315 
  )
10316 
 
3064 chandransh 10317 
  def __init__(self, success=None, ex=None,):
304 ashish 10318 
    self.success = success
3064 chandransh 10319 
    self.ex = ex
304 ashish 10320 
 
10321 
  def read(self, iprot):
10322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10324 
      return
10325 
    iprot.readStructBegin()
10326 
    while True:
10327 
      (fname, ftype, fid) = iprot.readFieldBegin()
10328 
      if ftype == TType.STOP:
10329 
        break
10330 
      if fid == 0:
10331 
        if ftype == TType.LIST:
10332 
          self.success = []
4133 chandransh 10333 
          (_etype152, _size149) = iprot.readListBegin()
10334 
          for _i153 in xrange(_size149):
10335 
            _elem154 = Order()
10336 
            _elem154.read(iprot)
10337 
            self.success.append(_elem154)
304 ashish 10338 
          iprot.readListEnd()
10339 
        else:
10340 
          iprot.skip(ftype)
3064 chandransh 10341 
      elif fid == 1:
10342 
        if ftype == TType.STRUCT:
10343 
          self.ex = TransactionServiceException()
10344 
          self.ex.read(iprot)
10345 
        else:
10346 
          iprot.skip(ftype)
304 ashish 10347 
      else:
10348 
        iprot.skip(ftype)
10349 
      iprot.readFieldEnd()
10350 
    iprot.readStructEnd()
10351 
 
10352 
  def write(self, oprot):
10353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10355 
      return
3064 chandransh 10356 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10357 
    if self.success is not None:
304 ashish 10358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10360 
      for iter155 in self.success:
10361 
        iter155.write(oprot)
304 ashish 10362 
      oprot.writeListEnd()
10363 
      oprot.writeFieldEnd()
3431 rajveer 10364 
    if self.ex is not None:
3064 chandransh 10365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10366 
      self.ex.write(oprot)
10367 
      oprot.writeFieldEnd()
304 ashish 10368 
    oprot.writeFieldStop()
10369 
    oprot.writeStructEnd()
10370 
 
3431 rajveer 10371 
  def validate(self):
10372 
    return
10373 
 
10374 
 
304 ashish 10375 
  def __repr__(self):
10376 
    L = ['%s=%r' % (key, value)
10377 
      for key, value in self.__dict__.iteritems()]
10378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10379 
 
10380 
  def __eq__(self, other):
10381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10382 
 
10383 
  def __ne__(self, other):
10384 
    return not (self == other)
10385 
 
3064 chandransh 10386 
class markOrdersAsDelivered_args:
304 ashish 10387 
  """
10388 
  Attributes:
3064 chandransh 10389 
   - providerId
10390 
   - deliveredOrders
304 ashish 10391 
  """
10392 
 
10393 
  thrift_spec = (
10394 
    None, # 0
3064 chandransh 10395 
    (1, TType.I64, 'providerId', None, None, ), # 1
10396 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10397 
  )
10398 
 
3064 chandransh 10399 
  def __init__(self, providerId=None, deliveredOrders=None,):
10400 
    self.providerId = providerId
10401 
    self.deliveredOrders = deliveredOrders
304 ashish 10402 
 
10403 
  def read(self, iprot):
10404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10406 
      return
10407 
    iprot.readStructBegin()
10408 
    while True:
10409 
      (fname, ftype, fid) = iprot.readFieldBegin()
10410 
      if ftype == TType.STOP:
10411 
        break
10412 
      if fid == 1:
10413 
        if ftype == TType.I64:
3064 chandransh 10414 
          self.providerId = iprot.readI64();
304 ashish 10415 
        else:
10416 
          iprot.skip(ftype)
10417 
      elif fid == 2:
3064 chandransh 10418 
        if ftype == TType.MAP:
10419 
          self.deliveredOrders = {}
4133 chandransh 10420 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10421 
          for _i160 in xrange(_size156):
10422 
            _key161 = iprot.readString();
10423 
            _val162 = iprot.readString();
10424 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10425 
          iprot.readMapEnd()
304 ashish 10426 
        else:
10427 
          iprot.skip(ftype)
10428 
      else:
10429 
        iprot.skip(ftype)
10430 
      iprot.readFieldEnd()
10431 
    iprot.readStructEnd()
10432 
 
10433 
  def write(self, oprot):
10434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10436 
      return
3064 chandransh 10437 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10438 
    if self.providerId is not None:
3064 chandransh 10439 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10440 
      oprot.writeI64(self.providerId)
304 ashish 10441 
      oprot.writeFieldEnd()
3431 rajveer 10442 
    if self.deliveredOrders is not None:
3064 chandransh 10443 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10444 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10445 
      for kiter163,viter164 in self.deliveredOrders.items():
10446 
        oprot.writeString(kiter163)
10447 
        oprot.writeString(viter164)
3064 chandransh 10448 
      oprot.writeMapEnd()
304 ashish 10449 
      oprot.writeFieldEnd()
10450 
    oprot.writeFieldStop()
10451 
    oprot.writeStructEnd()
10452 
 
3431 rajveer 10453 
  def validate(self):
10454 
    return
10455 
 
10456 
 
304 ashish 10457 
  def __repr__(self):
10458 
    L = ['%s=%r' % (key, value)
10459 
      for key, value in self.__dict__.iteritems()]
10460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10461 
 
10462 
  def __eq__(self, other):
10463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10464 
 
10465 
  def __ne__(self, other):
10466 
    return not (self == other)
10467 
 
3064 chandransh 10468 
class markOrdersAsDelivered_result:
10469 
  """
10470 
  Attributes:
10471 
   - ex
10472 
  """
304 ashish 10473 
 
10474 
  thrift_spec = (
3064 chandransh 10475 
    None, # 0
10476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10477 
  )
10478 
 
3064 chandransh 10479 
  def __init__(self, ex=None,):
10480 
    self.ex = ex
304 ashish 10481 
 
1596 ankur.sing 10482 
  def read(self, iprot):
10483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10485 
      return
10486 
    iprot.readStructBegin()
10487 
    while True:
10488 
      (fname, ftype, fid) = iprot.readFieldBegin()
10489 
      if ftype == TType.STOP:
10490 
        break
3064 chandransh 10491 
      if fid == 1:
10492 
        if ftype == TType.STRUCT:
10493 
          self.ex = TransactionServiceException()
10494 
          self.ex.read(iprot)
10495 
        else:
10496 
          iprot.skip(ftype)
1596 ankur.sing 10497 
      else:
10498 
        iprot.skip(ftype)
10499 
      iprot.readFieldEnd()
10500 
    iprot.readStructEnd()
10501 
 
10502 
  def write(self, oprot):
10503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10505 
      return
3064 chandransh 10506 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10507 
    if self.ex is not None:
3064 chandransh 10508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10509 
      self.ex.write(oprot)
10510 
      oprot.writeFieldEnd()
1596 ankur.sing 10511 
    oprot.writeFieldStop()
10512 
    oprot.writeStructEnd()
10513 
 
3431 rajveer 10514 
  def validate(self):
10515 
    return
10516 
 
10517 
 
1596 ankur.sing 10518 
  def __repr__(self):
10519 
    L = ['%s=%r' % (key, value)
10520 
      for key, value in self.__dict__.iteritems()]
10521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10522 
 
10523 
  def __eq__(self, other):
10524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10525 
 
10526 
  def __ne__(self, other):
10527 
    return not (self == other)
10528 
 
3064 chandransh 10529 
class markOrdersAsFailed_args:
1596 ankur.sing 10530 
  """
10531 
  Attributes:
3064 chandransh 10532 
   - providerId
10533 
   - returnedOrders
1596 ankur.sing 10534 
  """
10535 
 
10536 
  thrift_spec = (
3064 chandransh 10537 
    None, # 0
10538 
    (1, TType.I64, 'providerId', None, None, ), # 1
10539 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10540 
  )
10541 
 
3064 chandransh 10542 
  def __init__(self, providerId=None, returnedOrders=None,):
10543 
    self.providerId = providerId
10544 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10545 
 
10546 
  def read(self, iprot):
10547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10549 
      return
10550 
    iprot.readStructBegin()
10551 
    while True:
10552 
      (fname, ftype, fid) = iprot.readFieldBegin()
10553 
      if ftype == TType.STOP:
10554 
        break
3064 chandransh 10555 
      if fid == 1:
1596 ankur.sing 10556 
        if ftype == TType.I64:
3064 chandransh 10557 
          self.providerId = iprot.readI64();
1596 ankur.sing 10558 
        else:
10559 
          iprot.skip(ftype)
3064 chandransh 10560 
      elif fid == 2:
10561 
        if ftype == TType.MAP:
10562 
          self.returnedOrders = {}
4133 chandransh 10563 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10564 
          for _i169 in xrange(_size165):
10565 
            _key170 = iprot.readString();
10566 
            _val171 = iprot.readString();
10567 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10568 
          iprot.readMapEnd()
10569 
        else:
10570 
          iprot.skip(ftype)
1596 ankur.sing 10571 
      else:
10572 
        iprot.skip(ftype)
10573 
      iprot.readFieldEnd()
10574 
    iprot.readStructEnd()
10575 
 
10576 
  def write(self, oprot):
10577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10579 
      return
3064 chandransh 10580 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10581 
    if self.providerId is not None:
3064 chandransh 10582 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10583 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10584 
      oprot.writeFieldEnd()
3431 rajveer 10585 
    if self.returnedOrders is not None:
3064 chandransh 10586 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10587 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10588 
      for kiter172,viter173 in self.returnedOrders.items():
10589 
        oprot.writeString(kiter172)
10590 
        oprot.writeString(viter173)
3064 chandransh 10591 
      oprot.writeMapEnd()
10592 
      oprot.writeFieldEnd()
1596 ankur.sing 10593 
    oprot.writeFieldStop()
10594 
    oprot.writeStructEnd()
10595 
 
3431 rajveer 10596 
  def validate(self):
10597 
    return
10598 
 
10599 
 
1596 ankur.sing 10600 
  def __repr__(self):
10601 
    L = ['%s=%r' % (key, value)
10602 
      for key, value in self.__dict__.iteritems()]
10603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10604 
 
10605 
  def __eq__(self, other):
10606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10607 
 
10608 
  def __ne__(self, other):
10609 
    return not (self == other)
10610 
 
3064 chandransh 10611 
class markOrdersAsFailed_result:
10612 
  """
10613 
  Attributes:
10614 
   - ex
10615 
  """
1596 ankur.sing 10616 
 
1627 ankur.sing 10617 
  thrift_spec = (
3064 chandransh 10618 
    None, # 0
10619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10620 
  )
10621 
 
3064 chandransh 10622 
  def __init__(self, ex=None,):
10623 
    self.ex = ex
10624 
 
1627 ankur.sing 10625 
  def read(self, iprot):
10626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10628 
      return
10629 
    iprot.readStructBegin()
10630 
    while True:
10631 
      (fname, ftype, fid) = iprot.readFieldBegin()
10632 
      if ftype == TType.STOP:
10633 
        break
3064 chandransh 10634 
      if fid == 1:
10635 
        if ftype == TType.STRUCT:
10636 
          self.ex = TransactionServiceException()
10637 
          self.ex.read(iprot)
10638 
        else:
10639 
          iprot.skip(ftype)
1627 ankur.sing 10640 
      else:
10641 
        iprot.skip(ftype)
10642 
      iprot.readFieldEnd()
10643 
    iprot.readStructEnd()
10644 
 
10645 
  def write(self, oprot):
10646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10648 
      return
3064 chandransh 10649 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10650 
    if self.ex is not None:
3064 chandransh 10651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10652 
      self.ex.write(oprot)
10653 
      oprot.writeFieldEnd()
1627 ankur.sing 10654 
    oprot.writeFieldStop()
10655 
    oprot.writeStructEnd()
10656 
 
3431 rajveer 10657 
  def validate(self):
10658 
    return
10659 
 
10660 
 
1627 ankur.sing 10661 
  def __repr__(self):
10662 
    L = ['%s=%r' % (key, value)
10663 
      for key, value in self.__dict__.iteritems()]
10664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10665 
 
10666 
  def __eq__(self, other):
10667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10668 
 
10669 
  def __ne__(self, other):
10670 
    return not (self == other)
10671 
 
3064 chandransh 10672 
class updateNonDeliveryReason_args:
1627 ankur.sing 10673 
  """
10674 
  Attributes:
3064 chandransh 10675 
   - providerId
10676 
   - undeliveredOrders
1627 ankur.sing 10677 
  """
10678 
 
10679 
  thrift_spec = (
3064 chandransh 10680 
    None, # 0
10681 
    (1, TType.I64, 'providerId', None, None, ), # 1
10682 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10683 
  )
10684 
 
3064 chandransh 10685 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10686 
    self.providerId = providerId
10687 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10688 
 
10689 
  def read(self, iprot):
10690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10692 
      return
10693 
    iprot.readStructBegin()
10694 
    while True:
10695 
      (fname, ftype, fid) = iprot.readFieldBegin()
10696 
      if ftype == TType.STOP:
10697 
        break
3064 chandransh 10698 
      if fid == 1:
1627 ankur.sing 10699 
        if ftype == TType.I64:
3064 chandransh 10700 
          self.providerId = iprot.readI64();
1627 ankur.sing 10701 
        else:
10702 
          iprot.skip(ftype)
3064 chandransh 10703 
      elif fid == 2:
10704 
        if ftype == TType.MAP:
10705 
          self.undeliveredOrders = {}
4133 chandransh 10706 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10707 
          for _i178 in xrange(_size174):
10708 
            _key179 = iprot.readString();
10709 
            _val180 = iprot.readString();
10710 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10711 
          iprot.readMapEnd()
10712 
        else:
10713 
          iprot.skip(ftype)
1627 ankur.sing 10714 
      else:
10715 
        iprot.skip(ftype)
10716 
      iprot.readFieldEnd()
10717 
    iprot.readStructEnd()
10718 
 
10719 
  def write(self, oprot):
10720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10722 
      return
3064 chandransh 10723 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10724 
    if self.providerId is not None:
3064 chandransh 10725 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10726 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10727 
      oprot.writeFieldEnd()
3431 rajveer 10728 
    if self.undeliveredOrders is not None:
3064 chandransh 10729 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10730 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10731 
      for kiter181,viter182 in self.undeliveredOrders.items():
10732 
        oprot.writeString(kiter181)
10733 
        oprot.writeString(viter182)
3064 chandransh 10734 
      oprot.writeMapEnd()
10735 
      oprot.writeFieldEnd()
1627 ankur.sing 10736 
    oprot.writeFieldStop()
10737 
    oprot.writeStructEnd()
10738 
 
3431 rajveer 10739 
  def validate(self):
10740 
    return
10741 
 
10742 
 
1627 ankur.sing 10743 
  def __repr__(self):
10744 
    L = ['%s=%r' % (key, value)
10745 
      for key, value in self.__dict__.iteritems()]
10746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10747 
 
10748 
  def __eq__(self, other):
10749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10750 
 
10751 
  def __ne__(self, other):
10752 
    return not (self == other)
10753 
 
3064 chandransh 10754 
class updateNonDeliveryReason_result:
1627 ankur.sing 10755 
  """
10756 
  Attributes:
3064 chandransh 10757 
   - ex
1627 ankur.sing 10758 
  """
10759 
 
10760 
  thrift_spec = (
3064 chandransh 10761 
    None, # 0
10762 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10763 
  )
10764 
 
3064 chandransh 10765 
  def __init__(self, ex=None,):
10766 
    self.ex = ex
1627 ankur.sing 10767 
 
10768 
  def read(self, iprot):
10769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10771 
      return
10772 
    iprot.readStructBegin()
10773 
    while True:
10774 
      (fname, ftype, fid) = iprot.readFieldBegin()
10775 
      if ftype == TType.STOP:
10776 
        break
3064 chandransh 10777 
      if fid == 1:
10778 
        if ftype == TType.STRUCT:
10779 
          self.ex = TransactionServiceException()
10780 
          self.ex.read(iprot)
1627 ankur.sing 10781 
        else:
10782 
          iprot.skip(ftype)
10783 
      else:
10784 
        iprot.skip(ftype)
10785 
      iprot.readFieldEnd()
10786 
    iprot.readStructEnd()
10787 
 
10788 
  def write(self, oprot):
10789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10791 
      return
3064 chandransh 10792 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10793 
    if self.ex is not None:
3064 chandransh 10794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10795 
      self.ex.write(oprot)
1627 ankur.sing 10796 
      oprot.writeFieldEnd()
10797 
    oprot.writeFieldStop()
10798 
    oprot.writeStructEnd()
10799 
 
3431 rajveer 10800 
  def validate(self):
10801 
    return
10802 
 
10803 
 
1627 ankur.sing 10804 
  def __repr__(self):
10805 
    L = ['%s=%r' % (key, value)
10806 
      for key, value in self.__dict__.iteritems()]
10807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10808 
 
10809 
  def __eq__(self, other):
10810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10811 
 
10812 
  def __ne__(self, other):
10813 
    return not (self == other)
10814 
 
3064 chandransh 10815 
class getUndeliveredOrders_args:
1886 ankur.sing 10816 
  """
10817 
  Attributes:
3064 chandransh 10818 
   - providerId
10819 
   - warehouseId
1886 ankur.sing 10820 
  """
1627 ankur.sing 10821 
 
1886 ankur.sing 10822 
  thrift_spec = (
10823 
    None, # 0
3064 chandransh 10824 
    (1, TType.I64, 'providerId', None, None, ), # 1
10825 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10826 
  )
10827 
 
3064 chandransh 10828 
  def __init__(self, providerId=None, warehouseId=None,):
10829 
    self.providerId = providerId
10830 
    self.warehouseId = warehouseId
1886 ankur.sing 10831 
 
10832 
  def read(self, iprot):
10833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10835 
      return
10836 
    iprot.readStructBegin()
10837 
    while True:
10838 
      (fname, ftype, fid) = iprot.readFieldBegin()
10839 
      if ftype == TType.STOP:
10840 
        break
10841 
      if fid == 1:
10842 
        if ftype == TType.I64:
3064 chandransh 10843 
          self.providerId = iprot.readI64();
1886 ankur.sing 10844 
        else:
10845 
          iprot.skip(ftype)
3064 chandransh 10846 
      elif fid == 2:
10847 
        if ftype == TType.I64:
10848 
          self.warehouseId = iprot.readI64();
10849 
        else:
10850 
          iprot.skip(ftype)
1886 ankur.sing 10851 
      else:
10852 
        iprot.skip(ftype)
10853 
      iprot.readFieldEnd()
10854 
    iprot.readStructEnd()
10855 
 
10856 
  def write(self, oprot):
10857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10859 
      return
3064 chandransh 10860 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10861 
    if self.providerId is not None:
3064 chandransh 10862 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10863 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10864 
      oprot.writeFieldEnd()
3431 rajveer 10865 
    if self.warehouseId is not None:
3064 chandransh 10866 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10867 
      oprot.writeI64(self.warehouseId)
10868 
      oprot.writeFieldEnd()
1886 ankur.sing 10869 
    oprot.writeFieldStop()
10870 
    oprot.writeStructEnd()
10871 
 
3431 rajveer 10872 
  def validate(self):
10873 
    return
10874 
 
10875 
 
1886 ankur.sing 10876 
  def __repr__(self):
10877 
    L = ['%s=%r' % (key, value)
10878 
      for key, value in self.__dict__.iteritems()]
10879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10880 
 
10881 
  def __eq__(self, other):
10882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10883 
 
10884 
  def __ne__(self, other):
10885 
    return not (self == other)
10886 
 
3064 chandransh 10887 
class getUndeliveredOrders_result:
1886 ankur.sing 10888 
  """
10889 
  Attributes:
10890 
   - success
10891 
  """
10892 
 
10893 
  thrift_spec = (
10894 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10895 
  )
10896 
 
10897 
  def __init__(self, success=None,):
10898 
    self.success = success
10899 
 
10900 
  def read(self, iprot):
10901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10903 
      return
10904 
    iprot.readStructBegin()
10905 
    while True:
10906 
      (fname, ftype, fid) = iprot.readFieldBegin()
10907 
      if ftype == TType.STOP:
10908 
        break
10909 
      if fid == 0:
10910 
        if ftype == TType.LIST:
10911 
          self.success = []
4133 chandransh 10912 
          (_etype186, _size183) = iprot.readListBegin()
10913 
          for _i187 in xrange(_size183):
10914 
            _elem188 = Order()
10915 
            _elem188.read(iprot)
10916 
            self.success.append(_elem188)
1886 ankur.sing 10917 
          iprot.readListEnd()
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
3064 chandransh 10929 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10930 
    if self.success is not None:
1886 ankur.sing 10931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10933 
      for iter189 in self.success:
10934 
        iter189.write(oprot)
1886 ankur.sing 10935 
      oprot.writeListEnd()
10936 
      oprot.writeFieldEnd()
10937 
    oprot.writeFieldStop()
10938 
    oprot.writeStructEnd()
10939 
 
3431 rajveer 10940 
  def validate(self):
10941 
    return
10942 
 
10943 
 
1886 ankur.sing 10944 
  def __repr__(self):
10945 
    L = ['%s=%r' % (key, value)
10946 
      for key, value in self.__dict__.iteritems()]
10947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10948 
 
10949 
  def __eq__(self, other):
10950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10951 
 
10952 
  def __ne__(self, other):
10953 
    return not (self == other)
10954 
 
2536 chandransh 10955 
class toggleDOAFlag_args:
10956 
  """
10957 
  Attributes:
10958 
   - orderId
10959 
  """
1886 ankur.sing 10960 
 
2536 chandransh 10961 
  thrift_spec = (
10962 
    None, # 0
10963 
    (1, TType.I64, 'orderId', None, None, ), # 1
10964 
  )
10965 
 
10966 
  def __init__(self, orderId=None,):
10967 
    self.orderId = orderId
10968 
 
10969 
  def read(self, iprot):
10970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10972 
      return
10973 
    iprot.readStructBegin()
10974 
    while True:
10975 
      (fname, ftype, fid) = iprot.readFieldBegin()
10976 
      if ftype == TType.STOP:
10977 
        break
10978 
      if fid == 1:
10979 
        if ftype == TType.I64:
10980 
          self.orderId = iprot.readI64();
10981 
        else:
10982 
          iprot.skip(ftype)
10983 
      else:
10984 
        iprot.skip(ftype)
10985 
      iprot.readFieldEnd()
10986 
    iprot.readStructEnd()
10987 
 
10988 
  def write(self, oprot):
10989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10991 
      return
10992 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10993 
    if self.orderId is not None:
2536 chandransh 10994 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10995 
      oprot.writeI64(self.orderId)
10996 
      oprot.writeFieldEnd()
10997 
    oprot.writeFieldStop()
10998 
    oprot.writeStructEnd()
10999 
 
3431 rajveer 11000 
  def validate(self):
11001 
    return
11002 
 
11003 
 
2536 chandransh 11004 
  def __repr__(self):
11005 
    L = ['%s=%r' % (key, value)
11006 
      for key, value in self.__dict__.iteritems()]
11007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11008 
 
11009 
  def __eq__(self, other):
11010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11011 
 
11012 
  def __ne__(self, other):
11013 
    return not (self == other)
11014 
 
11015 
class toggleDOAFlag_result:
11016 
  """
11017 
  Attributes:
11018 
   - success
11019 
   - ex
11020 
  """
11021 
 
11022 
  thrift_spec = (
11023 
    (0, TType.BOOL, 'success', None, None, ), # 0
11024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11025 
  )
11026 
 
11027 
  def __init__(self, success=None, ex=None,):
11028 
    self.success = success
11029 
    self.ex = ex
11030 
 
11031 
  def read(self, iprot):
11032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11034 
      return
11035 
    iprot.readStructBegin()
11036 
    while True:
11037 
      (fname, ftype, fid) = iprot.readFieldBegin()
11038 
      if ftype == TType.STOP:
11039 
        break
11040 
      if fid == 0:
11041 
        if ftype == TType.BOOL:
11042 
          self.success = iprot.readBool();
11043 
        else:
11044 
          iprot.skip(ftype)
11045 
      elif fid == 1:
11046 
        if ftype == TType.STRUCT:
11047 
          self.ex = TransactionServiceException()
11048 
          self.ex.read(iprot)
11049 
        else:
11050 
          iprot.skip(ftype)
11051 
      else:
11052 
        iprot.skip(ftype)
11053 
      iprot.readFieldEnd()
11054 
    iprot.readStructEnd()
11055 
 
11056 
  def write(self, oprot):
11057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11059 
      return
11060 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11061 
    if self.success is not None:
2536 chandransh 11062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11063 
      oprot.writeBool(self.success)
11064 
      oprot.writeFieldEnd()
3431 rajveer 11065 
    if self.ex is not None:
2536 chandransh 11066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11067 
      self.ex.write(oprot)
11068 
      oprot.writeFieldEnd()
11069 
    oprot.writeFieldStop()
11070 
    oprot.writeStructEnd()
11071 
 
3431 rajveer 11072 
  def validate(self):
11073 
    return
11074 
 
11075 
 
2536 chandransh 11076 
  def __repr__(self):
11077 
    L = ['%s=%r' % (key, value)
11078 
      for key, value in self.__dict__.iteritems()]
11079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11080 
 
11081 
  def __eq__(self, other):
11082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11083 
 
11084 
  def __ne__(self, other):
11085 
    return not (self == other)
11086 
 
4454 rajveer 11087 
class markOrderDoaRequestReceived_args:
11088 
  """
11089 
  Attributes:
11090 
   - orderId
11091 
  """
11092 
 
11093 
  thrift_spec = (
11094 
    None, # 0
11095 
    (1, TType.I64, 'orderId', None, None, ), # 1
11096 
  )
11097 
 
11098 
  def __init__(self, orderId=None,):
11099 
    self.orderId = orderId
11100 
 
11101 
  def read(self, iprot):
11102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11104 
      return
11105 
    iprot.readStructBegin()
11106 
    while True:
11107 
      (fname, ftype, fid) = iprot.readFieldBegin()
11108 
      if ftype == TType.STOP:
11109 
        break
11110 
      if fid == 1:
11111 
        if ftype == TType.I64:
11112 
          self.orderId = iprot.readI64();
11113 
        else:
11114 
          iprot.skip(ftype)
11115 
      else:
11116 
        iprot.skip(ftype)
11117 
      iprot.readFieldEnd()
11118 
    iprot.readStructEnd()
11119 
 
11120 
  def write(self, oprot):
11121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11123 
      return
11124 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11125 
    if self.orderId is not None:
11126 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11127 
      oprot.writeI64(self.orderId)
11128 
      oprot.writeFieldEnd()
11129 
    oprot.writeFieldStop()
11130 
    oprot.writeStructEnd()
11131 
 
11132 
  def validate(self):
11133 
    return
11134 
 
11135 
 
11136 
  def __repr__(self):
11137 
    L = ['%s=%r' % (key, value)
11138 
      for key, value in self.__dict__.iteritems()]
11139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11140 
 
11141 
  def __eq__(self, other):
11142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11143 
 
11144 
  def __ne__(self, other):
11145 
    return not (self == other)
11146 
 
11147 
class markOrderDoaRequestReceived_result:
11148 
  """
11149 
  Attributes:
11150 
   - success
11151 
   - ex
11152 
  """
11153 
 
11154 
  thrift_spec = (
11155 
    (0, TType.BOOL, 'success', None, None, ), # 0
11156 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11157 
  )
11158 
 
11159 
  def __init__(self, success=None, ex=None,):
11160 
    self.success = success
11161 
    self.ex = ex
11162 
 
11163 
  def read(self, iprot):
11164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11166 
      return
11167 
    iprot.readStructBegin()
11168 
    while True:
11169 
      (fname, ftype, fid) = iprot.readFieldBegin()
11170 
      if ftype == TType.STOP:
11171 
        break
11172 
      if fid == 0:
11173 
        if ftype == TType.BOOL:
11174 
          self.success = iprot.readBool();
11175 
        else:
11176 
          iprot.skip(ftype)
11177 
      elif fid == 1:
11178 
        if ftype == TType.STRUCT:
11179 
          self.ex = TransactionServiceException()
11180 
          self.ex.read(iprot)
11181 
        else:
11182 
          iprot.skip(ftype)
11183 
      else:
11184 
        iprot.skip(ftype)
11185 
      iprot.readFieldEnd()
11186 
    iprot.readStructEnd()
11187 
 
11188 
  def write(self, oprot):
11189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11191 
      return
11192 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11193 
    if self.success is not None:
11194 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11195 
      oprot.writeBool(self.success)
11196 
      oprot.writeFieldEnd()
11197 
    if self.ex is not None:
11198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11199 
      self.ex.write(oprot)
11200 
      oprot.writeFieldEnd()
11201 
    oprot.writeFieldStop()
11202 
    oprot.writeStructEnd()
11203 
 
11204 
  def validate(self):
11205 
    return
11206 
 
11207 
 
11208 
  def __repr__(self):
11209 
    L = ['%s=%r' % (key, value)
11210 
      for key, value in self.__dict__.iteritems()]
11211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11212 
 
11213 
  def __eq__(self, other):
11214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11215 
 
11216 
  def __ne__(self, other):
11217 
    return not (self == other)
11218 
 
11219 
class markOrderDoaRequestAuthorized_args:
11220 
  """
11221 
  Attributes:
11222 
   - orderId
11223 
   - isAuthorized
11224 
  """
11225 
 
11226 
  thrift_spec = (
11227 
    None, # 0
11228 
    (1, TType.I64, 'orderId', None, None, ), # 1
11229 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11230 
  )
11231 
 
11232 
  def __init__(self, orderId=None, isAuthorized=None,):
11233 
    self.orderId = orderId
11234 
    self.isAuthorized = isAuthorized
11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      if fid == 1:
11246 
        if ftype == TType.I64:
11247 
          self.orderId = iprot.readI64();
11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      elif fid == 2:
11251 
        if ftype == TType.BOOL:
11252 
          self.isAuthorized = iprot.readBool();
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
11264 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11265 
    if self.orderId is not None:
11266 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11267 
      oprot.writeI64(self.orderId)
11268 
      oprot.writeFieldEnd()
11269 
    if self.isAuthorized is not None:
11270 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11271 
      oprot.writeBool(self.isAuthorized)
11272 
      oprot.writeFieldEnd()
11273 
    oprot.writeFieldStop()
11274 
    oprot.writeStructEnd()
11275 
 
11276 
  def validate(self):
11277 
    return
11278 
 
11279 
 
11280 
  def __repr__(self):
11281 
    L = ['%s=%r' % (key, value)
11282 
      for key, value in self.__dict__.iteritems()]
11283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11284 
 
11285 
  def __eq__(self, other):
11286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11287 
 
11288 
  def __ne__(self, other):
11289 
    return not (self == other)
11290 
 
11291 
class markOrderDoaRequestAuthorized_result:
11292 
  """
11293 
  Attributes:
11294 
   - success
11295 
   - ex
11296 
  """
11297 
 
11298 
  thrift_spec = (
11299 
    (0, TType.BOOL, 'success', None, None, ), # 0
11300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11301 
  )
11302 
 
11303 
  def __init__(self, success=None, ex=None,):
11304 
    self.success = success
11305 
    self.ex = ex
11306 
 
11307 
  def read(self, iprot):
11308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11310 
      return
11311 
    iprot.readStructBegin()
11312 
    while True:
11313 
      (fname, ftype, fid) = iprot.readFieldBegin()
11314 
      if ftype == TType.STOP:
11315 
        break
11316 
      if fid == 0:
11317 
        if ftype == TType.BOOL:
11318 
          self.success = iprot.readBool();
11319 
        else:
11320 
          iprot.skip(ftype)
11321 
      elif fid == 1:
11322 
        if ftype == TType.STRUCT:
11323 
          self.ex = TransactionServiceException()
11324 
          self.ex.read(iprot)
11325 
        else:
11326 
          iprot.skip(ftype)
11327 
      else:
11328 
        iprot.skip(ftype)
11329 
      iprot.readFieldEnd()
11330 
    iprot.readStructEnd()
11331 
 
11332 
  def write(self, oprot):
11333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11335 
      return
11336 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11337 
    if self.success is not None:
11338 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11339 
      oprot.writeBool(self.success)
11340 
      oprot.writeFieldEnd()
11341 
    if self.ex is not None:
11342 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11343 
      self.ex.write(oprot)
11344 
      oprot.writeFieldEnd()
11345 
    oprot.writeFieldStop()
11346 
    oprot.writeStructEnd()
11347 
 
11348 
  def validate(self):
11349 
    return
11350 
 
11351 
 
11352 
  def __repr__(self):
11353 
    L = ['%s=%r' % (key, value)
11354 
      for key, value in self.__dict__.iteritems()]
11355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11356 
 
11357 
  def __eq__(self, other):
11358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11359 
 
11360 
  def __ne__(self, other):
11361 
    return not (self == other)
11362 
 
4488 rajveer 11363 
class markOrderReturnRequestReceived_args:
11364 
  """
11365 
  Attributes:
11366 
   - orderId
11367 
  """
11368 
 
11369 
  thrift_spec = (
11370 
    None, # 0
11371 
    (1, TType.I64, 'orderId', None, None, ), # 1
11372 
  )
11373 
 
11374 
  def __init__(self, orderId=None,):
11375 
    self.orderId = orderId
11376 
 
11377 
  def read(self, iprot):
11378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11380 
      return
11381 
    iprot.readStructBegin()
11382 
    while True:
11383 
      (fname, ftype, fid) = iprot.readFieldBegin()
11384 
      if ftype == TType.STOP:
11385 
        break
11386 
      if fid == 1:
11387 
        if ftype == TType.I64:
11388 
          self.orderId = iprot.readI64();
11389 
        else:
11390 
          iprot.skip(ftype)
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
11400 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11401 
    if self.orderId is not None:
11402 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11403 
      oprot.writeI64(self.orderId)
11404 
      oprot.writeFieldEnd()
11405 
    oprot.writeFieldStop()
11406 
    oprot.writeStructEnd()
11407 
 
11408 
  def validate(self):
11409 
    return
11410 
 
11411 
 
11412 
  def __repr__(self):
11413 
    L = ['%s=%r' % (key, value)
11414 
      for key, value in self.__dict__.iteritems()]
11415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11416 
 
11417 
  def __eq__(self, other):
11418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11419 
 
11420 
  def __ne__(self, other):
11421 
    return not (self == other)
11422 
 
11423 
class markOrderReturnRequestReceived_result:
11424 
  """
11425 
  Attributes:
11426 
   - success
11427 
   - ex
11428 
  """
11429 
 
11430 
  thrift_spec = (
11431 
    (0, TType.BOOL, 'success', None, None, ), # 0
11432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11433 
  )
11434 
 
11435 
  def __init__(self, success=None, ex=None,):
11436 
    self.success = success
11437 
    self.ex = ex
11438 
 
11439 
  def read(self, iprot):
11440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11442 
      return
11443 
    iprot.readStructBegin()
11444 
    while True:
11445 
      (fname, ftype, fid) = iprot.readFieldBegin()
11446 
      if ftype == TType.STOP:
11447 
        break
11448 
      if fid == 0:
11449 
        if ftype == TType.BOOL:
11450 
          self.success = iprot.readBool();
11451 
        else:
11452 
          iprot.skip(ftype)
11453 
      elif fid == 1:
11454 
        if ftype == TType.STRUCT:
11455 
          self.ex = TransactionServiceException()
11456 
          self.ex.read(iprot)
11457 
        else:
11458 
          iprot.skip(ftype)
11459 
      else:
11460 
        iprot.skip(ftype)
11461 
      iprot.readFieldEnd()
11462 
    iprot.readStructEnd()
11463 
 
11464 
  def write(self, oprot):
11465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11467 
      return
11468 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11469 
    if self.success is not None:
11470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11471 
      oprot.writeBool(self.success)
11472 
      oprot.writeFieldEnd()
11473 
    if self.ex is not None:
11474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11475 
      self.ex.write(oprot)
11476 
      oprot.writeFieldEnd()
11477 
    oprot.writeFieldStop()
11478 
    oprot.writeStructEnd()
11479 
 
11480 
  def validate(self):
11481 
    return
11482 
 
11483 
 
11484 
  def __repr__(self):
11485 
    L = ['%s=%r' % (key, value)
11486 
      for key, value in self.__dict__.iteritems()]
11487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11488 
 
11489 
  def __eq__(self, other):
11490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11491 
 
11492 
  def __ne__(self, other):
11493 
    return not (self == other)
11494 
 
11495 
class markOrderReturnRequestAuthorized_args:
11496 
  """
11497 
  Attributes:
11498 
   - orderId
11499 
   - isAuthorized
11500 
  """
11501 
 
11502 
  thrift_spec = (
11503 
    None, # 0
11504 
    (1, TType.I64, 'orderId', None, None, ), # 1
11505 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11506 
  )
11507 
 
11508 
  def __init__(self, orderId=None, isAuthorized=None,):
11509 
    self.orderId = orderId
11510 
    self.isAuthorized = isAuthorized
11511 
 
11512 
  def read(self, iprot):
11513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11515 
      return
11516 
    iprot.readStructBegin()
11517 
    while True:
11518 
      (fname, ftype, fid) = iprot.readFieldBegin()
11519 
      if ftype == TType.STOP:
11520 
        break
11521 
      if fid == 1:
11522 
        if ftype == TType.I64:
11523 
          self.orderId = iprot.readI64();
11524 
        else:
11525 
          iprot.skip(ftype)
11526 
      elif fid == 2:
11527 
        if ftype == TType.BOOL:
11528 
          self.isAuthorized = iprot.readBool();
11529 
        else:
11530 
          iprot.skip(ftype)
11531 
      else:
11532 
        iprot.skip(ftype)
11533 
      iprot.readFieldEnd()
11534 
    iprot.readStructEnd()
11535 
 
11536 
  def write(self, oprot):
11537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11539 
      return
11540 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
11541 
    if self.orderId is not None:
11542 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11543 
      oprot.writeI64(self.orderId)
11544 
      oprot.writeFieldEnd()
11545 
    if self.isAuthorized is not None:
11546 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11547 
      oprot.writeBool(self.isAuthorized)
11548 
      oprot.writeFieldEnd()
11549 
    oprot.writeFieldStop()
11550 
    oprot.writeStructEnd()
11551 
 
11552 
  def validate(self):
11553 
    return
11554 
 
11555 
 
11556 
  def __repr__(self):
11557 
    L = ['%s=%r' % (key, value)
11558 
      for key, value in self.__dict__.iteritems()]
11559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11560 
 
11561 
  def __eq__(self, other):
11562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11563 
 
11564 
  def __ne__(self, other):
11565 
    return not (self == other)
11566 
 
11567 
class markOrderReturnRequestAuthorized_result:
11568 
  """
11569 
  Attributes:
11570 
   - success
11571 
   - ex
11572 
  """
11573 
 
11574 
  thrift_spec = (
11575 
    (0, TType.BOOL, 'success', None, None, ), # 0
11576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11577 
  )
11578 
 
11579 
  def __init__(self, success=None, ex=None,):
11580 
    self.success = success
11581 
    self.ex = ex
11582 
 
11583 
  def read(self, iprot):
11584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11586 
      return
11587 
    iprot.readStructBegin()
11588 
    while True:
11589 
      (fname, ftype, fid) = iprot.readFieldBegin()
11590 
      if ftype == TType.STOP:
11591 
        break
11592 
      if fid == 0:
11593 
        if ftype == TType.BOOL:
11594 
          self.success = iprot.readBool();
11595 
        else:
11596 
          iprot.skip(ftype)
11597 
      elif fid == 1:
11598 
        if ftype == TType.STRUCT:
11599 
          self.ex = TransactionServiceException()
11600 
          self.ex.read(iprot)
11601 
        else:
11602 
          iprot.skip(ftype)
11603 
      else:
11604 
        iprot.skip(ftype)
11605 
      iprot.readFieldEnd()
11606 
    iprot.readStructEnd()
11607 
 
11608 
  def write(self, oprot):
11609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11611 
      return
11612 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
11613 
    if self.success is not None:
11614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11615 
      oprot.writeBool(self.success)
11616 
      oprot.writeFieldEnd()
11617 
    if self.ex is not None:
11618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11619 
      self.ex.write(oprot)
11620 
      oprot.writeFieldEnd()
11621 
    oprot.writeFieldStop()
11622 
    oprot.writeStructEnd()
11623 
 
11624 
  def validate(self):
11625 
    return
11626 
 
11627 
 
11628 
  def __repr__(self):
11629 
    L = ['%s=%r' % (key, value)
11630 
      for key, value in self.__dict__.iteritems()]
11631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11632 
 
11633 
  def __eq__(self, other):
11634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11635 
 
11636 
  def __ne__(self, other):
11637 
    return not (self == other)
11638 
 
2536 chandransh 11639 
class requestPickupNumber_args:
11640 
  """
11641 
  Attributes:
11642 
   - orderId
4579 rajveer 11643 
   - providerId
2536 chandransh 11644 
  """
11645 
 
11646 
  thrift_spec = (
11647 
    None, # 0
11648 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 11649 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 11650 
  )
11651 
 
4579 rajveer 11652 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 11653 
    self.orderId = orderId
4579 rajveer 11654 
    self.providerId = providerId
2536 chandransh 11655 
 
11656 
  def read(self, iprot):
11657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11659 
      return
11660 
    iprot.readStructBegin()
11661 
    while True:
11662 
      (fname, ftype, fid) = iprot.readFieldBegin()
11663 
      if ftype == TType.STOP:
11664 
        break
11665 
      if fid == 1:
11666 
        if ftype == TType.I64:
11667 
          self.orderId = iprot.readI64();
11668 
        else:
11669 
          iprot.skip(ftype)
4579 rajveer 11670 
      elif fid == 2:
11671 
        if ftype == TType.I64:
11672 
          self.providerId = iprot.readI64();
11673 
        else:
11674 
          iprot.skip(ftype)
2536 chandransh 11675 
      else:
11676 
        iprot.skip(ftype)
11677 
      iprot.readFieldEnd()
11678 
    iprot.readStructEnd()
11679 
 
11680 
  def write(self, oprot):
11681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11683 
      return
11684 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 11685 
    if self.orderId is not None:
2536 chandransh 11686 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11687 
      oprot.writeI64(self.orderId)
11688 
      oprot.writeFieldEnd()
4579 rajveer 11689 
    if self.providerId is not None:
11690 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11691 
      oprot.writeI64(self.providerId)
11692 
      oprot.writeFieldEnd()
2536 chandransh 11693 
    oprot.writeFieldStop()
11694 
    oprot.writeStructEnd()
11695 
 
3431 rajveer 11696 
  def validate(self):
11697 
    return
11698 
 
11699 
 
2536 chandransh 11700 
  def __repr__(self):
11701 
    L = ['%s=%r' % (key, value)
11702 
      for key, value in self.__dict__.iteritems()]
11703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11704 
 
11705 
  def __eq__(self, other):
11706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11707 
 
11708 
  def __ne__(self, other):
11709 
    return not (self == other)
11710 
 
11711 
class requestPickupNumber_result:
11712 
  """
11713 
  Attributes:
11714 
   - success
11715 
   - ex
11716 
  """
11717 
 
11718 
  thrift_spec = (
11719 
    (0, TType.BOOL, 'success', None, None, ), # 0
11720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11721 
  )
11722 
 
11723 
  def __init__(self, success=None, ex=None,):
11724 
    self.success = success
11725 
    self.ex = ex
11726 
 
11727 
  def read(self, iprot):
11728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11730 
      return
11731 
    iprot.readStructBegin()
11732 
    while True:
11733 
      (fname, ftype, fid) = iprot.readFieldBegin()
11734 
      if ftype == TType.STOP:
11735 
        break
11736 
      if fid == 0:
11737 
        if ftype == TType.BOOL:
11738 
          self.success = iprot.readBool();
11739 
        else:
11740 
          iprot.skip(ftype)
11741 
      elif fid == 1:
11742 
        if ftype == TType.STRUCT:
11743 
          self.ex = TransactionServiceException()
11744 
          self.ex.read(iprot)
11745 
        else:
11746 
          iprot.skip(ftype)
11747 
      else:
11748 
        iprot.skip(ftype)
11749 
      iprot.readFieldEnd()
11750 
    iprot.readStructEnd()
11751 
 
11752 
  def write(self, oprot):
11753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11755 
      return
11756 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11757 
    if self.success is not None:
2536 chandransh 11758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11759 
      oprot.writeBool(self.success)
11760 
      oprot.writeFieldEnd()
3431 rajveer 11761 
    if self.ex is not None:
2536 chandransh 11762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11763 
      self.ex.write(oprot)
11764 
      oprot.writeFieldEnd()
11765 
    oprot.writeFieldStop()
11766 
    oprot.writeStructEnd()
11767 
 
3431 rajveer 11768 
  def validate(self):
11769 
    return
11770 
 
11771 
 
2536 chandransh 11772 
  def __repr__(self):
11773 
    L = ['%s=%r' % (key, value)
11774 
      for key, value in self.__dict__.iteritems()]
11775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11776 
 
11777 
  def __eq__(self, other):
11778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11779 
 
11780 
  def __ne__(self, other):
11781 
    return not (self == other)
11782 
 
11783 
class authorizePickup_args:
11784 
  """
11785 
  Attributes:
11786 
   - orderId
11787 
   - pickupNumber
11788 
  """
11789 
 
11790 
  thrift_spec = (
11791 
    None, # 0
11792 
    (1, TType.I64, 'orderId', None, None, ), # 1
11793 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11794 
  )
11795 
 
11796 
  def __init__(self, orderId=None, pickupNumber=None,):
11797 
    self.orderId = orderId
11798 
    self.pickupNumber = pickupNumber
11799 
 
11800 
  def read(self, iprot):
11801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11803 
      return
11804 
    iprot.readStructBegin()
11805 
    while True:
11806 
      (fname, ftype, fid) = iprot.readFieldBegin()
11807 
      if ftype == TType.STOP:
11808 
        break
11809 
      if fid == 1:
11810 
        if ftype == TType.I64:
11811 
          self.orderId = iprot.readI64();
11812 
        else:
11813 
          iprot.skip(ftype)
11814 
      elif fid == 2:
11815 
        if ftype == TType.STRING:
11816 
          self.pickupNumber = iprot.readString();
11817 
        else:
11818 
          iprot.skip(ftype)
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('authorizePickup_args')
3431 rajveer 11829 
    if self.orderId is not None:
2536 chandransh 11830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11831 
      oprot.writeI64(self.orderId)
11832 
      oprot.writeFieldEnd()
3431 rajveer 11833 
    if self.pickupNumber is not None:
2536 chandransh 11834 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11835 
      oprot.writeString(self.pickupNumber)
11836 
      oprot.writeFieldEnd()
11837 
    oprot.writeFieldStop()
11838 
    oprot.writeStructEnd()
11839 
 
3431 rajveer 11840 
  def validate(self):
11841 
    return
11842 
 
11843 
 
2536 chandransh 11844 
  def __repr__(self):
11845 
    L = ['%s=%r' % (key, value)
11846 
      for key, value in self.__dict__.iteritems()]
11847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11848 
 
11849 
  def __eq__(self, other):
11850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11851 
 
11852 
  def __ne__(self, other):
11853 
    return not (self == other)
11854 
 
11855 
class authorizePickup_result:
11856 
  """
11857 
  Attributes:
11858 
   - success
11859 
   - ex
11860 
  """
11861 
 
11862 
  thrift_spec = (
11863 
    (0, TType.BOOL, 'success', None, None, ), # 0
11864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11865 
  )
11866 
 
11867 
  def __init__(self, success=None, ex=None,):
11868 
    self.success = success
11869 
    self.ex = ex
11870 
 
11871 
  def read(self, iprot):
11872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11874 
      return
11875 
    iprot.readStructBegin()
11876 
    while True:
11877 
      (fname, ftype, fid) = iprot.readFieldBegin()
11878 
      if ftype == TType.STOP:
11879 
        break
11880 
      if fid == 0:
11881 
        if ftype == TType.BOOL:
11882 
          self.success = iprot.readBool();
11883 
        else:
11884 
          iprot.skip(ftype)
11885 
      elif fid == 1:
11886 
        if ftype == TType.STRUCT:
11887 
          self.ex = TransactionServiceException()
11888 
          self.ex.read(iprot)
11889 
        else:
11890 
          iprot.skip(ftype)
11891 
      else:
11892 
        iprot.skip(ftype)
11893 
      iprot.readFieldEnd()
11894 
    iprot.readStructEnd()
11895 
 
11896 
  def write(self, oprot):
11897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11899 
      return
11900 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11901 
    if self.success is not None:
2536 chandransh 11902 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11903 
      oprot.writeBool(self.success)
11904 
      oprot.writeFieldEnd()
3431 rajveer 11905 
    if self.ex is not None:
2536 chandransh 11906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11907 
      self.ex.write(oprot)
11908 
      oprot.writeFieldEnd()
11909 
    oprot.writeFieldStop()
11910 
    oprot.writeStructEnd()
11911 
 
3431 rajveer 11912 
  def validate(self):
11913 
    return
11914 
 
11915 
 
2536 chandransh 11916 
  def __repr__(self):
11917 
    L = ['%s=%r' % (key, value)
11918 
      for key, value in self.__dict__.iteritems()]
11919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11920 
 
11921 
  def __eq__(self, other):
11922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11923 
 
11924 
  def __ne__(self, other):
11925 
    return not (self == other)
11926 
 
2764 chandransh 11927 
class markDoasAsPickedUp_args:
11928 
  """
11929 
  Attributes:
11930 
   - providerId
11931 
   - pickupDetails
11932 
  """
11933 
 
11934 
  thrift_spec = (
11935 
    None, # 0
11936 
    (1, TType.I64, 'providerId', None, None, ), # 1
11937 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11938 
  )
11939 
 
11940 
  def __init__(self, providerId=None, pickupDetails=None,):
11941 
    self.providerId = providerId
11942 
    self.pickupDetails = pickupDetails
11943 
 
11944 
  def read(self, iprot):
11945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11947 
      return
11948 
    iprot.readStructBegin()
11949 
    while True:
11950 
      (fname, ftype, fid) = iprot.readFieldBegin()
11951 
      if ftype == TType.STOP:
11952 
        break
11953 
      if fid == 1:
11954 
        if ftype == TType.I64:
11955 
          self.providerId = iprot.readI64();
11956 
        else:
11957 
          iprot.skip(ftype)
11958 
      elif fid == 2:
11959 
        if ftype == TType.MAP:
11960 
          self.pickupDetails = {}
4133 chandransh 11961 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
11962 
          for _i194 in xrange(_size190):
11963 
            _key195 = iprot.readString();
11964 
            _val196 = iprot.readString();
11965 
            self.pickupDetails[_key195] = _val196
2764 chandransh 11966 
          iprot.readMapEnd()
11967 
        else:
11968 
          iprot.skip(ftype)
11969 
      else:
11970 
        iprot.skip(ftype)
11971 
      iprot.readFieldEnd()
11972 
    iprot.readStructEnd()
11973 
 
11974 
  def write(self, oprot):
11975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11977 
      return
11978 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 11979 
    if self.providerId is not None:
2764 chandransh 11980 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11981 
      oprot.writeI64(self.providerId)
11982 
      oprot.writeFieldEnd()
3431 rajveer 11983 
    if self.pickupDetails is not None:
2764 chandransh 11984 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11985 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11986 
      for kiter197,viter198 in self.pickupDetails.items():
11987 
        oprot.writeString(kiter197)
11988 
        oprot.writeString(viter198)
2764 chandransh 11989 
      oprot.writeMapEnd()
11990 
      oprot.writeFieldEnd()
11991 
    oprot.writeFieldStop()
11992 
    oprot.writeStructEnd()
11993 
 
3431 rajveer 11994 
  def validate(self):
11995 
    return
11996 
 
11997 
 
2764 chandransh 11998 
  def __repr__(self):
11999 
    L = ['%s=%r' % (key, value)
12000 
      for key, value in self.__dict__.iteritems()]
12001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12002 
 
12003 
  def __eq__(self, other):
12004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12005 
 
12006 
  def __ne__(self, other):
12007 
    return not (self == other)
12008 
 
12009 
class markDoasAsPickedUp_result:
12010 
  """
12011 
  Attributes:
12012 
   - success
12013 
  """
12014 
 
12015 
  thrift_spec = (
12016 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12017 
  )
12018 
 
12019 
  def __init__(self, success=None,):
12020 
    self.success = success
12021 
 
12022 
  def read(self, iprot):
12023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12025 
      return
12026 
    iprot.readStructBegin()
12027 
    while True:
12028 
      (fname, ftype, fid) = iprot.readFieldBegin()
12029 
      if ftype == TType.STOP:
12030 
        break
12031 
      if fid == 0:
12032 
        if ftype == TType.LIST:
12033 
          self.success = []
4133 chandransh 12034 
          (_etype202, _size199) = iprot.readListBegin()
12035 
          for _i203 in xrange(_size199):
12036 
            _elem204 = Order()
12037 
            _elem204.read(iprot)
12038 
            self.success.append(_elem204)
2764 chandransh 12039 
          iprot.readListEnd()
12040 
        else:
12041 
          iprot.skip(ftype)
12042 
      else:
12043 
        iprot.skip(ftype)
12044 
      iprot.readFieldEnd()
12045 
    iprot.readStructEnd()
12046 
 
12047 
  def write(self, oprot):
12048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12050 
      return
12051 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12052 
    if self.success is not None:
2764 chandransh 12053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12055 
      for iter205 in self.success:
12056 
        iter205.write(oprot)
2764 chandransh 12057 
      oprot.writeListEnd()
12058 
      oprot.writeFieldEnd()
12059 
    oprot.writeFieldStop()
12060 
    oprot.writeStructEnd()
12061 
 
3431 rajveer 12062 
  def validate(self):
12063 
    return
12064 
 
12065 
 
2764 chandransh 12066 
  def __repr__(self):
12067 
    L = ['%s=%r' % (key, value)
12068 
      for key, value in self.__dict__.iteritems()]
12069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12070 
 
12071 
  def __eq__(self, other):
12072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12073 
 
12074 
  def __ne__(self, other):
12075 
    return not (self == other)
12076 
 
2616 chandransh 12077 
class receiveReturn_args:
2591 chandransh 12078 
  """
12079 
  Attributes:
12080 
   - orderId
4479 rajveer 12081 
   - receiveCondition
2591 chandransh 12082 
  """
2536 chandransh 12083 
 
2591 chandransh 12084 
  thrift_spec = (
12085 
    None, # 0
12086 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12087 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12088 
  )
12089 
 
4479 rajveer 12090 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12091 
    self.orderId = orderId
4479 rajveer 12092 
    self.receiveCondition = receiveCondition
2591 chandransh 12093 
 
12094 
  def read(self, iprot):
12095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12097 
      return
12098 
    iprot.readStructBegin()
12099 
    while True:
12100 
      (fname, ftype, fid) = iprot.readFieldBegin()
12101 
      if ftype == TType.STOP:
12102 
        break
12103 
      if fid == 1:
12104 
        if ftype == TType.I64:
12105 
          self.orderId = iprot.readI64();
12106 
        else:
12107 
          iprot.skip(ftype)
4479 rajveer 12108 
      elif fid == 2:
12109 
        if ftype == TType.I64:
12110 
          self.receiveCondition = iprot.readI64();
12111 
        else:
12112 
          iprot.skip(ftype)
2591 chandransh 12113 
      else:
12114 
        iprot.skip(ftype)
12115 
      iprot.readFieldEnd()
12116 
    iprot.readStructEnd()
12117 
 
12118 
  def write(self, oprot):
12119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12121 
      return
2616 chandransh 12122 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12123 
    if self.orderId is not None:
2591 chandransh 12124 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12125 
      oprot.writeI64(self.orderId)
12126 
      oprot.writeFieldEnd()
4479 rajveer 12127 
    if self.receiveCondition is not None:
12128 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12129 
      oprot.writeI64(self.receiveCondition)
12130 
      oprot.writeFieldEnd()
2591 chandransh 12131 
    oprot.writeFieldStop()
12132 
    oprot.writeStructEnd()
12133 
 
3431 rajveer 12134 
  def validate(self):
12135 
    return
12136 
 
12137 
 
2591 chandransh 12138 
  def __repr__(self):
12139 
    L = ['%s=%r' % (key, value)
12140 
      for key, value in self.__dict__.iteritems()]
12141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12142 
 
12143 
  def __eq__(self, other):
12144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12145 
 
12146 
  def __ne__(self, other):
12147 
    return not (self == other)
12148 
 
2616 chandransh 12149 
class receiveReturn_result:
2591 chandransh 12150 
  """
12151 
  Attributes:
12152 
   - success
12153 
   - ex
12154 
  """
12155 
 
12156 
  thrift_spec = (
12157 
    (0, TType.BOOL, 'success', None, None, ), # 0
12158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12159 
  )
12160 
 
12161 
  def __init__(self, success=None, ex=None,):
12162 
    self.success = success
12163 
    self.ex = ex
12164 
 
12165 
  def read(self, iprot):
12166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12168 
      return
12169 
    iprot.readStructBegin()
12170 
    while True:
12171 
      (fname, ftype, fid) = iprot.readFieldBegin()
12172 
      if ftype == TType.STOP:
12173 
        break
12174 
      if fid == 0:
12175 
        if ftype == TType.BOOL:
12176 
          self.success = iprot.readBool();
12177 
        else:
12178 
          iprot.skip(ftype)
12179 
      elif fid == 1:
12180 
        if ftype == TType.STRUCT:
12181 
          self.ex = TransactionServiceException()
12182 
          self.ex.read(iprot)
12183 
        else:
12184 
          iprot.skip(ftype)
12185 
      else:
12186 
        iprot.skip(ftype)
12187 
      iprot.readFieldEnd()
12188 
    iprot.readStructEnd()
12189 
 
12190 
  def write(self, oprot):
12191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12193 
      return
2616 chandransh 12194 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12195 
    if self.success is not None:
2591 chandransh 12196 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12197 
      oprot.writeBool(self.success)
12198 
      oprot.writeFieldEnd()
3431 rajveer 12199 
    if self.ex is not None:
2591 chandransh 12200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12201 
      self.ex.write(oprot)
12202 
      oprot.writeFieldEnd()
12203 
    oprot.writeFieldStop()
12204 
    oprot.writeStructEnd()
12205 
 
3431 rajveer 12206 
  def validate(self):
12207 
    return
12208 
 
12209 
 
2591 chandransh 12210 
  def __repr__(self):
12211 
    L = ['%s=%r' % (key, value)
12212 
      for key, value in self.__dict__.iteritems()]
12213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12214 
 
12215 
  def __eq__(self, other):
12216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12217 
 
12218 
  def __ne__(self, other):
12219 
    return not (self == other)
12220 
 
12221 
class validateDoa_args:
12222 
  """
12223 
  Attributes:
12224 
   - orderId
12225 
   - isValid
12226 
  """
12227 
 
12228 
  thrift_spec = (
12229 
    None, # 0
12230 
    (1, TType.I64, 'orderId', None, None, ), # 1
12231 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12232 
  )
12233 
 
12234 
  def __init__(self, orderId=None, isValid=None,):
12235 
    self.orderId = orderId
12236 
    self.isValid = isValid
12237 
 
12238 
  def read(self, iprot):
12239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12241 
      return
12242 
    iprot.readStructBegin()
12243 
    while True:
12244 
      (fname, ftype, fid) = iprot.readFieldBegin()
12245 
      if ftype == TType.STOP:
12246 
        break
12247 
      if fid == 1:
12248 
        if ftype == TType.I64:
12249 
          self.orderId = iprot.readI64();
12250 
        else:
12251 
          iprot.skip(ftype)
12252 
      elif fid == 2:
12253 
        if ftype == TType.BOOL:
12254 
          self.isValid = iprot.readBool();
12255 
        else:
12256 
          iprot.skip(ftype)
12257 
      else:
12258 
        iprot.skip(ftype)
12259 
      iprot.readFieldEnd()
12260 
    iprot.readStructEnd()
12261 
 
12262 
  def write(self, oprot):
12263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12265 
      return
12266 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12267 
    if self.orderId is not None:
2591 chandransh 12268 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12269 
      oprot.writeI64(self.orderId)
12270 
      oprot.writeFieldEnd()
3431 rajveer 12271 
    if self.isValid is not None:
2591 chandransh 12272 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12273 
      oprot.writeBool(self.isValid)
12274 
      oprot.writeFieldEnd()
12275 
    oprot.writeFieldStop()
12276 
    oprot.writeStructEnd()
12277 
 
3431 rajveer 12278 
  def validate(self):
12279 
    return
12280 
 
12281 
 
2591 chandransh 12282 
  def __repr__(self):
12283 
    L = ['%s=%r' % (key, value)
12284 
      for key, value in self.__dict__.iteritems()]
12285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12286 
 
12287 
  def __eq__(self, other):
12288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12289 
 
12290 
  def __ne__(self, other):
12291 
    return not (self == other)
12292 
 
12293 
class validateDoa_result:
12294 
  """
12295 
  Attributes:
12296 
   - success
12297 
   - ex
12298 
  """
12299 
 
12300 
  thrift_spec = (
12301 
    (0, TType.BOOL, 'success', None, None, ), # 0
12302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12303 
  )
12304 
 
12305 
  def __init__(self, success=None, ex=None,):
12306 
    self.success = success
12307 
    self.ex = ex
12308 
 
12309 
  def read(self, iprot):
12310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12312 
      return
12313 
    iprot.readStructBegin()
12314 
    while True:
12315 
      (fname, ftype, fid) = iprot.readFieldBegin()
12316 
      if ftype == TType.STOP:
12317 
        break
12318 
      if fid == 0:
12319 
        if ftype == TType.BOOL:
12320 
          self.success = iprot.readBool();
12321 
        else:
12322 
          iprot.skip(ftype)
12323 
      elif fid == 1:
12324 
        if ftype == TType.STRUCT:
12325 
          self.ex = TransactionServiceException()
12326 
          self.ex.read(iprot)
12327 
        else:
12328 
          iprot.skip(ftype)
12329 
      else:
12330 
        iprot.skip(ftype)
12331 
      iprot.readFieldEnd()
12332 
    iprot.readStructEnd()
12333 
 
12334 
  def write(self, oprot):
12335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12337 
      return
12338 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12339 
    if self.success is not None:
2591 chandransh 12340 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12341 
      oprot.writeBool(self.success)
12342 
      oprot.writeFieldEnd()
3431 rajveer 12343 
    if self.ex is not None:
2591 chandransh 12344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12345 
      self.ex.write(oprot)
12346 
      oprot.writeFieldEnd()
12347 
    oprot.writeFieldStop()
12348 
    oprot.writeStructEnd()
12349 
 
3431 rajveer 12350 
  def validate(self):
12351 
    return
12352 
 
12353 
 
2591 chandransh 12354 
  def __repr__(self):
12355 
    L = ['%s=%r' % (key, value)
12356 
      for key, value in self.__dict__.iteritems()]
12357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12358 
 
12359 
  def __eq__(self, other):
12360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12361 
 
12362 
  def __ne__(self, other):
12363 
    return not (self == other)
12364 
 
4495 rajveer 12365 
class validateReturnProduct_args:
12366 
  """
12367 
  Attributes:
12368 
   - orderId
12369 
   - isUsable
12370 
  """
12371 
 
12372 
  thrift_spec = (
12373 
    None, # 0
12374 
    (1, TType.I64, 'orderId', None, None, ), # 1
12375 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12376 
  )
12377 
 
12378 
  def __init__(self, orderId=None, isUsable=None,):
12379 
    self.orderId = orderId
12380 
    self.isUsable = isUsable
12381 
 
12382 
  def read(self, iprot):
12383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12385 
      return
12386 
    iprot.readStructBegin()
12387 
    while True:
12388 
      (fname, ftype, fid) = iprot.readFieldBegin()
12389 
      if ftype == TType.STOP:
12390 
        break
12391 
      if fid == 1:
12392 
        if ftype == TType.I64:
12393 
          self.orderId = iprot.readI64();
12394 
        else:
12395 
          iprot.skip(ftype)
12396 
      elif fid == 2:
12397 
        if ftype == TType.BOOL:
12398 
          self.isUsable = iprot.readBool();
12399 
        else:
12400 
          iprot.skip(ftype)
12401 
      else:
12402 
        iprot.skip(ftype)
12403 
      iprot.readFieldEnd()
12404 
    iprot.readStructEnd()
12405 
 
12406 
  def write(self, oprot):
12407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12409 
      return
12410 
    oprot.writeStructBegin('validateReturnProduct_args')
12411 
    if self.orderId is not None:
12412 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12413 
      oprot.writeI64(self.orderId)
12414 
      oprot.writeFieldEnd()
12415 
    if self.isUsable is not None:
12416 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12417 
      oprot.writeBool(self.isUsable)
12418 
      oprot.writeFieldEnd()
12419 
    oprot.writeFieldStop()
12420 
    oprot.writeStructEnd()
12421 
 
12422 
  def validate(self):
12423 
    return
12424 
 
12425 
 
12426 
  def __repr__(self):
12427 
    L = ['%s=%r' % (key, value)
12428 
      for key, value in self.__dict__.iteritems()]
12429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12430 
 
12431 
  def __eq__(self, other):
12432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12433 
 
12434 
  def __ne__(self, other):
12435 
    return not (self == other)
12436 
 
12437 
class validateReturnProduct_result:
12438 
  """
12439 
  Attributes:
12440 
   - success
12441 
   - ex
12442 
  """
12443 
 
12444 
  thrift_spec = (
12445 
    (0, TType.BOOL, 'success', None, None, ), # 0
12446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12447 
  )
12448 
 
12449 
  def __init__(self, success=None, ex=None,):
12450 
    self.success = success
12451 
    self.ex = ex
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      if fid == 0:
12463 
        if ftype == TType.BOOL:
12464 
          self.success = iprot.readBool();
12465 
        else:
12466 
          iprot.skip(ftype)
12467 
      elif fid == 1:
12468 
        if ftype == TType.STRUCT:
12469 
          self.ex = TransactionServiceException()
12470 
          self.ex.read(iprot)
12471 
        else:
12472 
          iprot.skip(ftype)
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
12482 
    oprot.writeStructBegin('validateReturnProduct_result')
12483 
    if self.success is not None:
12484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12485 
      oprot.writeBool(self.success)
12486 
      oprot.writeFieldEnd()
12487 
    if self.ex is not None:
12488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12489 
      self.ex.write(oprot)
12490 
      oprot.writeFieldEnd()
12491 
    oprot.writeFieldStop()
12492 
    oprot.writeStructEnd()
12493 
 
12494 
  def validate(self):
12495 
    return
12496 
 
12497 
 
12498 
  def __repr__(self):
12499 
    L = ['%s=%r' % (key, value)
12500 
      for key, value in self.__dict__.iteritems()]
12501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12502 
 
12503 
  def __eq__(self, other):
12504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12505 
 
12506 
  def __ne__(self, other):
12507 
    return not (self == other)
12508 
 
2616 chandransh 12509 
class reshipOrder_args:
12510 
  """
12511 
  Attributes:
12512 
   - orderId
12513 
  """
2591 chandransh 12514 
 
2616 chandransh 12515 
  thrift_spec = (
12516 
    None, # 0
12517 
    (1, TType.I64, 'orderId', None, None, ), # 1
12518 
  )
12519 
 
12520 
  def __init__(self, orderId=None,):
12521 
    self.orderId = orderId
12522 
 
12523 
  def read(self, iprot):
12524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12526 
      return
12527 
    iprot.readStructBegin()
12528 
    while True:
12529 
      (fname, ftype, fid) = iprot.readFieldBegin()
12530 
      if ftype == TType.STOP:
12531 
        break
12532 
      if fid == 1:
12533 
        if ftype == TType.I64:
12534 
          self.orderId = iprot.readI64();
12535 
        else:
12536 
          iprot.skip(ftype)
12537 
      else:
12538 
        iprot.skip(ftype)
12539 
      iprot.readFieldEnd()
12540 
    iprot.readStructEnd()
12541 
 
12542 
  def write(self, oprot):
12543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12545 
      return
12546 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 12547 
    if self.orderId is not None:
2616 chandransh 12548 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12549 
      oprot.writeI64(self.orderId)
12550 
      oprot.writeFieldEnd()
12551 
    oprot.writeFieldStop()
12552 
    oprot.writeStructEnd()
12553 
 
3431 rajveer 12554 
  def validate(self):
12555 
    return
12556 
 
12557 
 
2616 chandransh 12558 
  def __repr__(self):
12559 
    L = ['%s=%r' % (key, value)
12560 
      for key, value in self.__dict__.iteritems()]
12561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12562 
 
12563 
  def __eq__(self, other):
12564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12565 
 
12566 
  def __ne__(self, other):
12567 
    return not (self == other)
12568 
 
12569 
class reshipOrder_result:
12570 
  """
12571 
  Attributes:
12572 
   - success
12573 
   - ex
12574 
  """
12575 
 
12576 
  thrift_spec = (
12577 
    (0, TType.I64, 'success', None, None, ), # 0
12578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12579 
  )
12580 
 
12581 
  def __init__(self, success=None, ex=None,):
12582 
    self.success = success
12583 
    self.ex = ex
12584 
 
12585 
  def read(self, iprot):
12586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12588 
      return
12589 
    iprot.readStructBegin()
12590 
    while True:
12591 
      (fname, ftype, fid) = iprot.readFieldBegin()
12592 
      if ftype == TType.STOP:
12593 
        break
12594 
      if fid == 0:
12595 
        if ftype == TType.I64:
12596 
          self.success = iprot.readI64();
12597 
        else:
12598 
          iprot.skip(ftype)
12599 
      elif fid == 1:
12600 
        if ftype == TType.STRUCT:
12601 
          self.ex = TransactionServiceException()
12602 
          self.ex.read(iprot)
12603 
        else:
12604 
          iprot.skip(ftype)
12605 
      else:
12606 
        iprot.skip(ftype)
12607 
      iprot.readFieldEnd()
12608 
    iprot.readStructEnd()
12609 
 
12610 
  def write(self, oprot):
12611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12613 
      return
12614 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 12615 
    if self.success is not None:
2616 chandransh 12616 
      oprot.writeFieldBegin('success', TType.I64, 0)
12617 
      oprot.writeI64(self.success)
12618 
      oprot.writeFieldEnd()
3431 rajveer 12619 
    if self.ex is not None:
2616 chandransh 12620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12621 
      self.ex.write(oprot)
12622 
      oprot.writeFieldEnd()
12623 
    oprot.writeFieldStop()
12624 
    oprot.writeStructEnd()
12625 
 
3431 rajveer 12626 
  def validate(self):
12627 
    return
12628 
 
12629 
 
2616 chandransh 12630 
  def __repr__(self):
12631 
    L = ['%s=%r' % (key, value)
12632 
      for key, value in self.__dict__.iteritems()]
12633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12634 
 
12635 
  def __eq__(self, other):
12636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12637 
 
12638 
  def __ne__(self, other):
12639 
    return not (self == other)
12640 
 
12641 
class refundOrder_args:
12642 
  """
12643 
  Attributes:
12644 
   - orderId
3226 chandransh 12645 
   - refundedBy
12646 
   - reason
2616 chandransh 12647 
  """
12648 
 
12649 
  thrift_spec = (
12650 
    None, # 0
12651 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 12652 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12653 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 12654 
  )
12655 
 
3226 chandransh 12656 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 12657 
    self.orderId = orderId
3226 chandransh 12658 
    self.refundedBy = refundedBy
12659 
    self.reason = reason
2616 chandransh 12660 
 
12661 
  def read(self, iprot):
12662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12664 
      return
12665 
    iprot.readStructBegin()
12666 
    while True:
12667 
      (fname, ftype, fid) = iprot.readFieldBegin()
12668 
      if ftype == TType.STOP:
12669 
        break
12670 
      if fid == 1:
12671 
        if ftype == TType.I64:
12672 
          self.orderId = iprot.readI64();
12673 
        else:
12674 
          iprot.skip(ftype)
3226 chandransh 12675 
      elif fid == 2:
12676 
        if ftype == TType.STRING:
12677 
          self.refundedBy = iprot.readString();
12678 
        else:
12679 
          iprot.skip(ftype)
12680 
      elif fid == 3:
12681 
        if ftype == TType.STRING:
12682 
          self.reason = iprot.readString();
12683 
        else:
12684 
          iprot.skip(ftype)
2616 chandransh 12685 
      else:
12686 
        iprot.skip(ftype)
12687 
      iprot.readFieldEnd()
12688 
    iprot.readStructEnd()
12689 
 
12690 
  def write(self, oprot):
12691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12693 
      return
12694 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 12695 
    if self.orderId is not None:
2616 chandransh 12696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12697 
      oprot.writeI64(self.orderId)
12698 
      oprot.writeFieldEnd()
3431 rajveer 12699 
    if self.refundedBy is not None:
3226 chandransh 12700 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12701 
      oprot.writeString(self.refundedBy)
12702 
      oprot.writeFieldEnd()
3431 rajveer 12703 
    if self.reason is not None:
3226 chandransh 12704 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12705 
      oprot.writeString(self.reason)
12706 
      oprot.writeFieldEnd()
2616 chandransh 12707 
    oprot.writeFieldStop()
12708 
    oprot.writeStructEnd()
12709 
 
3431 rajveer 12710 
  def validate(self):
12711 
    return
12712 
 
12713 
 
2616 chandransh 12714 
  def __repr__(self):
12715 
    L = ['%s=%r' % (key, value)
12716 
      for key, value in self.__dict__.iteritems()]
12717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12718 
 
12719 
  def __eq__(self, other):
12720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12721 
 
12722 
  def __ne__(self, other):
12723 
    return not (self == other)
12724 
 
12725 
class refundOrder_result:
12726 
  """
12727 
  Attributes:
12728 
   - success
12729 
   - ex
12730 
  """
12731 
 
12732 
  thrift_spec = (
12733 
    (0, TType.BOOL, 'success', None, None, ), # 0
12734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12735 
  )
12736 
 
12737 
  def __init__(self, success=None, ex=None,):
12738 
    self.success = success
12739 
    self.ex = ex
12740 
 
12741 
  def read(self, iprot):
12742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12744 
      return
12745 
    iprot.readStructBegin()
12746 
    while True:
12747 
      (fname, ftype, fid) = iprot.readFieldBegin()
12748 
      if ftype == TType.STOP:
12749 
        break
12750 
      if fid == 0:
12751 
        if ftype == TType.BOOL:
12752 
          self.success = iprot.readBool();
12753 
        else:
12754 
          iprot.skip(ftype)
12755 
      elif fid == 1:
12756 
        if ftype == TType.STRUCT:
12757 
          self.ex = TransactionServiceException()
12758 
          self.ex.read(iprot)
12759 
        else:
12760 
          iprot.skip(ftype)
12761 
      else:
12762 
        iprot.skip(ftype)
12763 
      iprot.readFieldEnd()
12764 
    iprot.readStructEnd()
12765 
 
12766 
  def write(self, oprot):
12767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12769 
      return
12770 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 12771 
    if self.success is not None:
2616 chandransh 12772 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12773 
      oprot.writeBool(self.success)
12774 
      oprot.writeFieldEnd()
3431 rajveer 12775 
    if self.ex is not None:
2616 chandransh 12776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12777 
      self.ex.write(oprot)
12778 
      oprot.writeFieldEnd()
12779 
    oprot.writeFieldStop()
12780 
    oprot.writeStructEnd()
12781 
 
3431 rajveer 12782 
  def validate(self):
12783 
    return
12784 
 
12785 
 
2616 chandransh 12786 
  def __repr__(self):
12787 
    L = ['%s=%r' % (key, value)
12788 
      for key, value in self.__dict__.iteritems()]
12789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12790 
 
12791 
  def __eq__(self, other):
12792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12793 
 
12794 
  def __ne__(self, other):
12795 
    return not (self == other)
12796 
 
2690 chandransh 12797 
class getReturnOrders_args:
12798 
  """
12799 
  Attributes:
12800 
   - warehouseId
12801 
   - fromDate
12802 
   - toDate
12803 
  """
2616 chandransh 12804 
 
2690 chandransh 12805 
  thrift_spec = (
12806 
    None, # 0
12807 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12808 
    (2, TType.I64, 'fromDate', None, None, ), # 2
12809 
    (3, TType.I64, 'toDate', None, None, ), # 3
12810 
  )
12811 
 
12812 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
12813 
    self.warehouseId = warehouseId
12814 
    self.fromDate = fromDate
12815 
    self.toDate = toDate
12816 
 
12817 
  def read(self, iprot):
12818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12820 
      return
12821 
    iprot.readStructBegin()
12822 
    while True:
12823 
      (fname, ftype, fid) = iprot.readFieldBegin()
12824 
      if ftype == TType.STOP:
12825 
        break
12826 
      if fid == 1:
12827 
        if ftype == TType.I64:
12828 
          self.warehouseId = iprot.readI64();
12829 
        else:
12830 
          iprot.skip(ftype)
12831 
      elif fid == 2:
12832 
        if ftype == TType.I64:
12833 
          self.fromDate = iprot.readI64();
12834 
        else:
12835 
          iprot.skip(ftype)
12836 
      elif fid == 3:
12837 
        if ftype == TType.I64:
12838 
          self.toDate = iprot.readI64();
12839 
        else:
12840 
          iprot.skip(ftype)
12841 
      else:
12842 
        iprot.skip(ftype)
12843 
      iprot.readFieldEnd()
12844 
    iprot.readStructEnd()
12845 
 
12846 
  def write(self, oprot):
12847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12849 
      return
12850 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 12851 
    if self.warehouseId is not None:
2690 chandransh 12852 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12853 
      oprot.writeI64(self.warehouseId)
12854 
      oprot.writeFieldEnd()
3431 rajveer 12855 
    if self.fromDate is not None:
2690 chandransh 12856 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
12857 
      oprot.writeI64(self.fromDate)
12858 
      oprot.writeFieldEnd()
3431 rajveer 12859 
    if self.toDate is not None:
2690 chandransh 12860 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
12861 
      oprot.writeI64(self.toDate)
12862 
      oprot.writeFieldEnd()
12863 
    oprot.writeFieldStop()
12864 
    oprot.writeStructEnd()
12865 
 
3431 rajveer 12866 
  def validate(self):
12867 
    return
12868 
 
12869 
 
2690 chandransh 12870 
  def __repr__(self):
12871 
    L = ['%s=%r' % (key, value)
12872 
      for key, value in self.__dict__.iteritems()]
12873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12874 
 
12875 
  def __eq__(self, other):
12876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12877 
 
12878 
  def __ne__(self, other):
12879 
    return not (self == other)
12880 
 
12881 
class getReturnOrders_result:
12882 
  """
12883 
  Attributes:
12884 
   - success
12885 
  """
12886 
 
12887 
  thrift_spec = (
12888 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12889 
  )
12890 
 
12891 
  def __init__(self, success=None,):
12892 
    self.success = success
12893 
 
12894 
  def read(self, iprot):
12895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12897 
      return
12898 
    iprot.readStructBegin()
12899 
    while True:
12900 
      (fname, ftype, fid) = iprot.readFieldBegin()
12901 
      if ftype == TType.STOP:
12902 
        break
12903 
      if fid == 0:
12904 
        if ftype == TType.LIST:
12905 
          self.success = []
4133 chandransh 12906 
          (_etype209, _size206) = iprot.readListBegin()
12907 
          for _i210 in xrange(_size206):
12908 
            _elem211 = ReturnOrder()
12909 
            _elem211.read(iprot)
12910 
            self.success.append(_elem211)
2690 chandransh 12911 
          iprot.readListEnd()
12912 
        else:
12913 
          iprot.skip(ftype)
12914 
      else:
12915 
        iprot.skip(ftype)
12916 
      iprot.readFieldEnd()
12917 
    iprot.readStructEnd()
12918 
 
12919 
  def write(self, oprot):
12920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12922 
      return
12923 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12924 
    if self.success is not None:
2690 chandransh 12925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12927 
      for iter212 in self.success:
12928 
        iter212.write(oprot)
2690 chandransh 12929 
      oprot.writeListEnd()
12930 
      oprot.writeFieldEnd()
12931 
    oprot.writeFieldStop()
12932 
    oprot.writeStructEnd()
12933 
 
3431 rajveer 12934 
  def validate(self):
12935 
    return
12936 
 
12937 
 
2690 chandransh 12938 
  def __repr__(self):
12939 
    L = ['%s=%r' % (key, value)
12940 
      for key, value in self.__dict__.iteritems()]
12941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12942 
 
12943 
  def __eq__(self, other):
12944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12945 
 
12946 
  def __ne__(self, other):
12947 
    return not (self == other)
12948 
 
2700 chandransh 12949 
class getReturnOrder_args:
12950 
  """
12951 
  Attributes:
12952 
   - id
12953 
  """
12954 
 
12955 
  thrift_spec = (
12956 
    None, # 0
12957 
    (1, TType.I64, 'id', None, None, ), # 1
12958 
  )
12959 
 
12960 
  def __init__(self, id=None,):
12961 
    self.id = id
12962 
 
12963 
  def read(self, iprot):
12964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12966 
      return
12967 
    iprot.readStructBegin()
12968 
    while True:
12969 
      (fname, ftype, fid) = iprot.readFieldBegin()
12970 
      if ftype == TType.STOP:
12971 
        break
12972 
      if fid == 1:
12973 
        if ftype == TType.I64:
12974 
          self.id = iprot.readI64();
12975 
        else:
12976 
          iprot.skip(ftype)
12977 
      else:
12978 
        iprot.skip(ftype)
12979 
      iprot.readFieldEnd()
12980 
    iprot.readStructEnd()
12981 
 
12982 
  def write(self, oprot):
12983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12985 
      return
12986 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 12987 
    if self.id is not None:
2700 chandransh 12988 
      oprot.writeFieldBegin('id', TType.I64, 1)
12989 
      oprot.writeI64(self.id)
12990 
      oprot.writeFieldEnd()
12991 
    oprot.writeFieldStop()
12992 
    oprot.writeStructEnd()
12993 
 
3431 rajveer 12994 
  def validate(self):
12995 
    return
12996 
 
12997 
 
2700 chandransh 12998 
  def __repr__(self):
12999 
    L = ['%s=%r' % (key, value)
13000 
      for key, value in self.__dict__.iteritems()]
13001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13002 
 
13003 
  def __eq__(self, other):
13004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13005 
 
13006 
  def __ne__(self, other):
13007 
    return not (self == other)
13008 
 
13009 
class getReturnOrder_result:
13010 
  """
13011 
  Attributes:
13012 
   - success
13013 
   - ex
13014 
  """
13015 
 
13016 
  thrift_spec = (
13017 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13019 
  )
13020 
 
13021 
  def __init__(self, success=None, ex=None,):
13022 
    self.success = success
13023 
    self.ex = ex
13024 
 
13025 
  def read(self, iprot):
13026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13028 
      return
13029 
    iprot.readStructBegin()
13030 
    while True:
13031 
      (fname, ftype, fid) = iprot.readFieldBegin()
13032 
      if ftype == TType.STOP:
13033 
        break
13034 
      if fid == 0:
13035 
        if ftype == TType.STRUCT:
13036 
          self.success = ReturnOrder()
13037 
          self.success.read(iprot)
13038 
        else:
13039 
          iprot.skip(ftype)
13040 
      elif fid == 1:
13041 
        if ftype == TType.STRUCT:
13042 
          self.ex = TransactionServiceException()
13043 
          self.ex.read(iprot)
13044 
        else:
13045 
          iprot.skip(ftype)
13046 
      else:
13047 
        iprot.skip(ftype)
13048 
      iprot.readFieldEnd()
13049 
    iprot.readStructEnd()
13050 
 
13051 
  def write(self, oprot):
13052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13054 
      return
13055 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13056 
    if self.success is not None:
2700 chandransh 13057 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13058 
      self.success.write(oprot)
13059 
      oprot.writeFieldEnd()
3431 rajveer 13060 
    if self.ex is not None:
2700 chandransh 13061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13062 
      self.ex.write(oprot)
13063 
      oprot.writeFieldEnd()
13064 
    oprot.writeFieldStop()
13065 
    oprot.writeStructEnd()
13066 
 
3431 rajveer 13067 
  def validate(self):
13068 
    return
13069 
 
13070 
 
2700 chandransh 13071 
  def __repr__(self):
13072 
    L = ['%s=%r' % (key, value)
13073 
      for key, value in self.__dict__.iteritems()]
13074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13075 
 
13076 
  def __eq__(self, other):
13077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13078 
 
13079 
  def __ne__(self, other):
13080 
    return not (self == other)
13081 
 
2690 chandransh 13082 
class processReturn_args:
13083 
  """
13084 
  Attributes:
13085 
   - returnOrderId
13086 
  """
13087 
 
13088 
  thrift_spec = (
13089 
    None, # 0
13090 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13091 
  )
13092 
 
13093 
  def __init__(self, returnOrderId=None,):
13094 
    self.returnOrderId = returnOrderId
13095 
 
13096 
  def read(self, iprot):
13097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13099 
      return
13100 
    iprot.readStructBegin()
13101 
    while True:
13102 
      (fname, ftype, fid) = iprot.readFieldBegin()
13103 
      if ftype == TType.STOP:
13104 
        break
13105 
      if fid == 1:
13106 
        if ftype == TType.I64:
13107 
          self.returnOrderId = iprot.readI64();
13108 
        else:
13109 
          iprot.skip(ftype)
13110 
      else:
13111 
        iprot.skip(ftype)
13112 
      iprot.readFieldEnd()
13113 
    iprot.readStructEnd()
13114 
 
13115 
  def write(self, oprot):
13116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13118 
      return
13119 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13120 
    if self.returnOrderId is not None:
2690 chandransh 13121 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13122 
      oprot.writeI64(self.returnOrderId)
13123 
      oprot.writeFieldEnd()
13124 
    oprot.writeFieldStop()
13125 
    oprot.writeStructEnd()
13126 
 
3431 rajveer 13127 
  def validate(self):
13128 
    return
13129 
 
13130 
 
2690 chandransh 13131 
  def __repr__(self):
13132 
    L = ['%s=%r' % (key, value)
13133 
      for key, value in self.__dict__.iteritems()]
13134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13135 
 
13136 
  def __eq__(self, other):
13137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13138 
 
13139 
  def __ne__(self, other):
13140 
    return not (self == other)
13141 
 
13142 
class processReturn_result:
13143 
  """
13144 
  Attributes:
13145 
   - ex
13146 
  """
13147 
 
13148 
  thrift_spec = (
13149 
    None, # 0
13150 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13151 
  )
13152 
 
13153 
  def __init__(self, ex=None,):
13154 
    self.ex = ex
13155 
 
13156 
  def read(self, iprot):
13157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13159 
      return
13160 
    iprot.readStructBegin()
13161 
    while True:
13162 
      (fname, ftype, fid) = iprot.readFieldBegin()
13163 
      if ftype == TType.STOP:
13164 
        break
13165 
      if fid == 1:
13166 
        if ftype == TType.STRUCT:
13167 
          self.ex = TransactionServiceException()
13168 
          self.ex.read(iprot)
13169 
        else:
13170 
          iprot.skip(ftype)
13171 
      else:
13172 
        iprot.skip(ftype)
13173 
      iprot.readFieldEnd()
13174 
    iprot.readStructEnd()
13175 
 
13176 
  def write(self, oprot):
13177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13179 
      return
13180 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13181 
    if self.ex is not None:
2690 chandransh 13182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13183 
      self.ex.write(oprot)
13184 
      oprot.writeFieldEnd()
13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
3431 rajveer 13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
2690 chandransh 13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
2819 chandransh 13203 
class createPurchaseOrder_args:
13204 
  """
13205 
  Attributes:
13206 
   - warehouseId
13207 
  """
2690 chandransh 13208 
 
2819 chandransh 13209 
  thrift_spec = (
13210 
    None, # 0
13211 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13212 
  )
13213 
 
13214 
  def __init__(self, warehouseId=None,):
13215 
    self.warehouseId = warehouseId
13216 
 
13217 
  def read(self, iprot):
13218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13220 
      return
13221 
    iprot.readStructBegin()
13222 
    while True:
13223 
      (fname, ftype, fid) = iprot.readFieldBegin()
13224 
      if ftype == TType.STOP:
13225 
        break
13226 
      if fid == 1:
13227 
        if ftype == TType.I64:
13228 
          self.warehouseId = iprot.readI64();
13229 
        else:
13230 
          iprot.skip(ftype)
13231 
      else:
13232 
        iprot.skip(ftype)
13233 
      iprot.readFieldEnd()
13234 
    iprot.readStructEnd()
13235 
 
13236 
  def write(self, oprot):
13237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13239 
      return
13240 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13241 
    if self.warehouseId is not None:
2819 chandransh 13242 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13243 
      oprot.writeI64(self.warehouseId)
13244 
      oprot.writeFieldEnd()
13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
3431 rajveer 13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
2819 chandransh 13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
13263 
class createPurchaseOrder_result:
13264 
  """
13265 
  Attributes:
13266 
   - success
13267 
   - ex
13268 
  """
13269 
 
13270 
  thrift_spec = (
13271 
    (0, TType.I64, 'success', None, None, ), # 0
13272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13273 
  )
13274 
 
13275 
  def __init__(self, success=None, ex=None,):
13276 
    self.success = success
13277 
    self.ex = ex
13278 
 
13279 
  def read(self, iprot):
13280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13282 
      return
13283 
    iprot.readStructBegin()
13284 
    while True:
13285 
      (fname, ftype, fid) = iprot.readFieldBegin()
13286 
      if ftype == TType.STOP:
13287 
        break
13288 
      if fid == 0:
13289 
        if ftype == TType.I64:
13290 
          self.success = iprot.readI64();
13291 
        else:
13292 
          iprot.skip(ftype)
13293 
      elif fid == 1:
13294 
        if ftype == TType.STRUCT:
13295 
          self.ex = TransactionServiceException()
13296 
          self.ex.read(iprot)
13297 
        else:
13298 
          iprot.skip(ftype)
13299 
      else:
13300 
        iprot.skip(ftype)
13301 
      iprot.readFieldEnd()
13302 
    iprot.readStructEnd()
13303 
 
13304 
  def write(self, oprot):
13305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13307 
      return
13308 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13309 
    if self.success is not None:
2819 chandransh 13310 
      oprot.writeFieldBegin('success', TType.I64, 0)
13311 
      oprot.writeI64(self.success)
13312 
      oprot.writeFieldEnd()
3431 rajveer 13313 
    if self.ex is not None:
2819 chandransh 13314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13315 
      self.ex.write(oprot)
13316 
      oprot.writeFieldEnd()
13317 
    oprot.writeFieldStop()
13318 
    oprot.writeStructEnd()
13319 
 
3431 rajveer 13320 
  def validate(self):
13321 
    return
13322 
 
13323 
 
2819 chandransh 13324 
  def __repr__(self):
13325 
    L = ['%s=%r' % (key, value)
13326 
      for key, value in self.__dict__.iteritems()]
13327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13328 
 
13329 
  def __eq__(self, other):
13330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13331 
 
13332 
  def __ne__(self, other):
13333 
    return not (self == other)
3451 chandransh 13334 
 
13335 
class updateWeight_args:
13336 
  """
13337 
  Attributes:
13338 
   - orderId
13339 
   - weight
13340 
  """
13341 
 
13342 
  thrift_spec = (
13343 
    None, # 0
13344 
    (1, TType.I64, 'orderId', None, None, ), # 1
13345 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13346 
  )
13347 
 
13348 
  def __init__(self, orderId=None, weight=None,):
13349 
    self.orderId = orderId
13350 
    self.weight = weight
13351 
 
13352 
  def read(self, iprot):
13353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13355 
      return
13356 
    iprot.readStructBegin()
13357 
    while True:
13358 
      (fname, ftype, fid) = iprot.readFieldBegin()
13359 
      if ftype == TType.STOP:
13360 
        break
13361 
      if fid == 1:
13362 
        if ftype == TType.I64:
13363 
          self.orderId = iprot.readI64();
13364 
        else:
13365 
          iprot.skip(ftype)
13366 
      elif fid == 2:
13367 
        if ftype == TType.DOUBLE:
13368 
          self.weight = iprot.readDouble();
13369 
        else:
13370 
          iprot.skip(ftype)
13371 
      else:
13372 
        iprot.skip(ftype)
13373 
      iprot.readFieldEnd()
13374 
    iprot.readStructEnd()
13375 
 
13376 
  def write(self, oprot):
13377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13379 
      return
13380 
    oprot.writeStructBegin('updateWeight_args')
13381 
    if self.orderId is not None:
13382 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13383 
      oprot.writeI64(self.orderId)
13384 
      oprot.writeFieldEnd()
13385 
    if self.weight is not None:
13386 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13387 
      oprot.writeDouble(self.weight)
13388 
      oprot.writeFieldEnd()
13389 
    oprot.writeFieldStop()
13390 
    oprot.writeStructEnd()
13391 
 
13392 
  def validate(self):
13393 
    return
13394 
 
13395 
 
13396 
  def __repr__(self):
13397 
    L = ['%s=%r' % (key, value)
13398 
      for key, value in self.__dict__.iteritems()]
13399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13400 
 
13401 
  def __eq__(self, other):
13402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13403 
 
13404 
  def __ne__(self, other):
13405 
    return not (self == other)
13406 
 
13407 
class updateWeight_result:
13408 
  """
13409 
  Attributes:
13410 
   - success
13411 
   - ex
13412 
  """
13413 
 
13414 
  thrift_spec = (
13415 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13417 
  )
13418 
 
13419 
  def __init__(self, success=None, ex=None,):
13420 
    self.success = success
13421 
    self.ex = ex
13422 
 
13423 
  def read(self, iprot):
13424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13426 
      return
13427 
    iprot.readStructBegin()
13428 
    while True:
13429 
      (fname, ftype, fid) = iprot.readFieldBegin()
13430 
      if ftype == TType.STOP:
13431 
        break
13432 
      if fid == 0:
13433 
        if ftype == TType.STRUCT:
13434 
          self.success = Order()
13435 
          self.success.read(iprot)
13436 
        else:
13437 
          iprot.skip(ftype)
13438 
      elif fid == 1:
13439 
        if ftype == TType.STRUCT:
13440 
          self.ex = TransactionServiceException()
13441 
          self.ex.read(iprot)
13442 
        else:
13443 
          iprot.skip(ftype)
13444 
      else:
13445 
        iprot.skip(ftype)
13446 
      iprot.readFieldEnd()
13447 
    iprot.readStructEnd()
13448 
 
13449 
  def write(self, oprot):
13450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13452 
      return
13453 
    oprot.writeStructBegin('updateWeight_result')
13454 
    if self.success is not None:
13455 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13456 
      self.success.write(oprot)
13457 
      oprot.writeFieldEnd()
13458 
    if self.ex is not None:
13459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13460 
      self.ex.write(oprot)
13461 
      oprot.writeFieldEnd()
13462 
    oprot.writeFieldStop()
13463 
    oprot.writeStructEnd()
13464 
 
13465 
  def validate(self):
13466 
    return
13467 
 
13468 
 
13469 
  def __repr__(self):
13470 
    L = ['%s=%r' % (key, value)
13471 
      for key, value in self.__dict__.iteritems()]
13472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13473 
 
13474 
  def __eq__(self, other):
13475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13476 
 
13477 
  def __ne__(self, other):
13478 
    return not (self == other)
3469 chandransh 13479 
 
13480 
class changeItem_args:
13481 
  """
13482 
  Attributes:
13483 
   - orderId
13484 
   - itemId
13485 
  """
13486 
 
13487 
  thrift_spec = (
13488 
    None, # 0
13489 
    (1, TType.I64, 'orderId', None, None, ), # 1
13490 
    (2, TType.I64, 'itemId', None, None, ), # 2
13491 
  )
13492 
 
13493 
  def __init__(self, orderId=None, itemId=None,):
13494 
    self.orderId = orderId
13495 
    self.itemId = itemId
13496 
 
13497 
  def read(self, iprot):
13498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13500 
      return
13501 
    iprot.readStructBegin()
13502 
    while True:
13503 
      (fname, ftype, fid) = iprot.readFieldBegin()
13504 
      if ftype == TType.STOP:
13505 
        break
13506 
      if fid == 1:
13507 
        if ftype == TType.I64:
13508 
          self.orderId = iprot.readI64();
13509 
        else:
13510 
          iprot.skip(ftype)
13511 
      elif fid == 2:
13512 
        if ftype == TType.I64:
13513 
          self.itemId = iprot.readI64();
13514 
        else:
13515 
          iprot.skip(ftype)
13516 
      else:
13517 
        iprot.skip(ftype)
13518 
      iprot.readFieldEnd()
13519 
    iprot.readStructEnd()
13520 
 
13521 
  def write(self, oprot):
13522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13524 
      return
13525 
    oprot.writeStructBegin('changeItem_args')
13526 
    if self.orderId is not None:
13527 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13528 
      oprot.writeI64(self.orderId)
13529 
      oprot.writeFieldEnd()
13530 
    if self.itemId is not None:
13531 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13532 
      oprot.writeI64(self.itemId)
13533 
      oprot.writeFieldEnd()
13534 
    oprot.writeFieldStop()
13535 
    oprot.writeStructEnd()
13536 
 
13537 
  def validate(self):
13538 
    return
13539 
 
13540 
 
13541 
  def __repr__(self):
13542 
    L = ['%s=%r' % (key, value)
13543 
      for key, value in self.__dict__.iteritems()]
13544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13545 
 
13546 
  def __eq__(self, other):
13547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13548 
 
13549 
  def __ne__(self, other):
13550 
    return not (self == other)
13551 
 
13552 
class changeItem_result:
13553 
  """
13554 
  Attributes:
13555 
   - success
13556 
   - ex
13557 
  """
13558 
 
13559 
  thrift_spec = (
13560 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13562 
  )
13563 
 
13564 
  def __init__(self, success=None, ex=None,):
13565 
    self.success = success
13566 
    self.ex = ex
13567 
 
13568 
  def read(self, iprot):
13569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13571 
      return
13572 
    iprot.readStructBegin()
13573 
    while True:
13574 
      (fname, ftype, fid) = iprot.readFieldBegin()
13575 
      if ftype == TType.STOP:
13576 
        break
13577 
      if fid == 0:
13578 
        if ftype == TType.STRUCT:
13579 
          self.success = Order()
13580 
          self.success.read(iprot)
13581 
        else:
13582 
          iprot.skip(ftype)
13583 
      elif fid == 1:
13584 
        if ftype == TType.STRUCT:
13585 
          self.ex = TransactionServiceException()
13586 
          self.ex.read(iprot)
13587 
        else:
13588 
          iprot.skip(ftype)
13589 
      else:
13590 
        iprot.skip(ftype)
13591 
      iprot.readFieldEnd()
13592 
    iprot.readStructEnd()
13593 
 
13594 
  def write(self, oprot):
13595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13597 
      return
13598 
    oprot.writeStructBegin('changeItem_result')
13599 
    if self.success is not None:
13600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13601 
      self.success.write(oprot)
13602 
      oprot.writeFieldEnd()
13603 
    if self.ex is not None:
13604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13605 
      self.ex.write(oprot)
13606 
      oprot.writeFieldEnd()
13607 
    oprot.writeFieldStop()
13608 
    oprot.writeStructEnd()
13609 
 
13610 
  def validate(self):
13611 
    return
13612 
 
13613 
 
13614 
  def __repr__(self):
13615 
    L = ['%s=%r' % (key, value)
13616 
      for key, value in self.__dict__.iteritems()]
13617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13618 
 
13619 
  def __eq__(self, other):
13620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13621 
 
13622 
  def __ne__(self, other):
13623 
    return not (self == other)
13624 
 
13625 
class shiftToWarehouse_args:
13626 
  """
13627 
  Attributes:
13628 
   - orderId
13629 
   - warehouseId
13630 
  """
13631 
 
13632 
  thrift_spec = (
13633 
    None, # 0
13634 
    (1, TType.I64, 'orderId', None, None, ), # 1
13635 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13636 
  )
13637 
 
13638 
  def __init__(self, orderId=None, warehouseId=None,):
13639 
    self.orderId = orderId
13640 
    self.warehouseId = warehouseId
13641 
 
13642 
  def read(self, iprot):
13643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13645 
      return
13646 
    iprot.readStructBegin()
13647 
    while True:
13648 
      (fname, ftype, fid) = iprot.readFieldBegin()
13649 
      if ftype == TType.STOP:
13650 
        break
13651 
      if fid == 1:
13652 
        if ftype == TType.I64:
13653 
          self.orderId = iprot.readI64();
13654 
        else:
13655 
          iprot.skip(ftype)
13656 
      elif fid == 2:
13657 
        if ftype == TType.I64:
13658 
          self.warehouseId = iprot.readI64();
13659 
        else:
13660 
          iprot.skip(ftype)
13661 
      else:
13662 
        iprot.skip(ftype)
13663 
      iprot.readFieldEnd()
13664 
    iprot.readStructEnd()
13665 
 
13666 
  def write(self, oprot):
13667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13669 
      return
13670 
    oprot.writeStructBegin('shiftToWarehouse_args')
13671 
    if self.orderId is not None:
13672 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13673 
      oprot.writeI64(self.orderId)
13674 
      oprot.writeFieldEnd()
13675 
    if self.warehouseId is not None:
13676 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13677 
      oprot.writeI64(self.warehouseId)
13678 
      oprot.writeFieldEnd()
13679 
    oprot.writeFieldStop()
13680 
    oprot.writeStructEnd()
13681 
 
13682 
  def validate(self):
13683 
    return
13684 
 
13685 
 
13686 
  def __repr__(self):
13687 
    L = ['%s=%r' % (key, value)
13688 
      for key, value in self.__dict__.iteritems()]
13689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13690 
 
13691 
  def __eq__(self, other):
13692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13693 
 
13694 
  def __ne__(self, other):
13695 
    return not (self == other)
13696 
 
13697 
class shiftToWarehouse_result:
13698 
  """
13699 
  Attributes:
13700 
   - success
13701 
   - ex
13702 
  """
13703 
 
13704 
  thrift_spec = (
13705 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13707 
  )
13708 
 
13709 
  def __init__(self, success=None, ex=None,):
13710 
    self.success = success
13711 
    self.ex = ex
13712 
 
13713 
  def read(self, iprot):
13714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13716 
      return
13717 
    iprot.readStructBegin()
13718 
    while True:
13719 
      (fname, ftype, fid) = iprot.readFieldBegin()
13720 
      if ftype == TType.STOP:
13721 
        break
13722 
      if fid == 0:
13723 
        if ftype == TType.STRUCT:
13724 
          self.success = Order()
13725 
          self.success.read(iprot)
13726 
        else:
13727 
          iprot.skip(ftype)
13728 
      elif fid == 1:
13729 
        if ftype == TType.STRUCT:
13730 
          self.ex = TransactionServiceException()
13731 
          self.ex.read(iprot)
13732 
        else:
13733 
          iprot.skip(ftype)
13734 
      else:
13735 
        iprot.skip(ftype)
13736 
      iprot.readFieldEnd()
13737 
    iprot.readStructEnd()
13738 
 
13739 
  def write(self, oprot):
13740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13742 
      return
13743 
    oprot.writeStructBegin('shiftToWarehouse_result')
13744 
    if self.success is not None:
13745 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13746 
      self.success.write(oprot)
13747 
      oprot.writeFieldEnd()
13748 
    if self.ex is not None:
13749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13750 
      self.ex.write(oprot)
13751 
      oprot.writeFieldEnd()
13752 
    oprot.writeFieldStop()
13753 
    oprot.writeStructEnd()
13754 
 
13755 
  def validate(self):
13756 
    return
13757 
 
13758 
 
13759 
  def __repr__(self):
13760 
    L = ['%s=%r' % (key, value)
13761 
      for key, value in self.__dict__.iteritems()]
13762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13763 
 
13764 
  def __eq__(self, other):
13765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13766 
 
13767 
  def __ne__(self, other):
13768 
    return not (self == other)
3553 chandransh 13769 
 
13770 
class addDelayReason_args:
13771 
  """
13772 
  Attributes:
13773 
   - orderId
13774 
   - delayReason
3986 chandransh 13775 
   - furtherDelay
3553 chandransh 13776 
  """
13777 
 
13778 
  thrift_spec = (
13779 
    None, # 0
13780 
    (1, TType.I64, 'orderId', None, None, ), # 1
13781 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 13782 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 13783 
  )
13784 
 
3986 chandransh 13785 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 13786 
    self.orderId = orderId
13787 
    self.delayReason = delayReason
3986 chandransh 13788 
    self.furtherDelay = furtherDelay
3553 chandransh 13789 
 
13790 
  def read(self, iprot):
13791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13793 
      return
13794 
    iprot.readStructBegin()
13795 
    while True:
13796 
      (fname, ftype, fid) = iprot.readFieldBegin()
13797 
      if ftype == TType.STOP:
13798 
        break
13799 
      if fid == 1:
13800 
        if ftype == TType.I64:
13801 
          self.orderId = iprot.readI64();
13802 
        else:
13803 
          iprot.skip(ftype)
13804 
      elif fid == 2:
13805 
        if ftype == TType.I32:
13806 
          self.delayReason = iprot.readI32();
13807 
        else:
13808 
          iprot.skip(ftype)
3986 chandransh 13809 
      elif fid == 3:
13810 
        if ftype == TType.I64:
13811 
          self.furtherDelay = iprot.readI64();
13812 
        else:
13813 
          iprot.skip(ftype)
3553 chandransh 13814 
      else:
13815 
        iprot.skip(ftype)
13816 
      iprot.readFieldEnd()
13817 
    iprot.readStructEnd()
13818 
 
13819 
  def write(self, oprot):
13820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13822 
      return
13823 
    oprot.writeStructBegin('addDelayReason_args')
13824 
    if self.orderId is not None:
13825 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13826 
      oprot.writeI64(self.orderId)
13827 
      oprot.writeFieldEnd()
13828 
    if self.delayReason is not None:
13829 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
13830 
      oprot.writeI32(self.delayReason)
13831 
      oprot.writeFieldEnd()
3986 chandransh 13832 
    if self.furtherDelay is not None:
13833 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
13834 
      oprot.writeI64(self.furtherDelay)
13835 
      oprot.writeFieldEnd()
3553 chandransh 13836 
    oprot.writeFieldStop()
13837 
    oprot.writeStructEnd()
13838 
 
13839 
  def validate(self):
13840 
    return
13841 
 
13842 
 
13843 
  def __repr__(self):
13844 
    L = ['%s=%r' % (key, value)
13845 
      for key, value in self.__dict__.iteritems()]
13846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13847 
 
13848 
  def __eq__(self, other):
13849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13850 
 
13851 
  def __ne__(self, other):
13852 
    return not (self == other)
13853 
 
13854 
class addDelayReason_result:
13855 
  """
13856 
  Attributes:
13857 
   - success
13858 
   - ex
13859 
  """
13860 
 
13861 
  thrift_spec = (
13862 
    (0, TType.BOOL, 'success', None, None, ), # 0
13863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13864 
  )
13865 
 
13866 
  def __init__(self, success=None, ex=None,):
13867 
    self.success = success
13868 
    self.ex = ex
13869 
 
13870 
  def read(self, iprot):
13871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13873 
      return
13874 
    iprot.readStructBegin()
13875 
    while True:
13876 
      (fname, ftype, fid) = iprot.readFieldBegin()
13877 
      if ftype == TType.STOP:
13878 
        break
13879 
      if fid == 0:
13880 
        if ftype == TType.BOOL:
13881 
          self.success = iprot.readBool();
13882 
        else:
13883 
          iprot.skip(ftype)
13884 
      elif fid == 1:
13885 
        if ftype == TType.STRUCT:
13886 
          self.ex = TransactionServiceException()
13887 
          self.ex.read(iprot)
13888 
        else:
13889 
          iprot.skip(ftype)
13890 
      else:
13891 
        iprot.skip(ftype)
13892 
      iprot.readFieldEnd()
13893 
    iprot.readStructEnd()
13894 
 
13895 
  def write(self, oprot):
13896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13898 
      return
13899 
    oprot.writeStructBegin('addDelayReason_result')
13900 
    if self.success is not None:
13901 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13902 
      oprot.writeBool(self.success)
13903 
      oprot.writeFieldEnd()
13904 
    if self.ex is not None:
13905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13906 
      self.ex.write(oprot)
13907 
      oprot.writeFieldEnd()
13908 
    oprot.writeFieldStop()
13909 
    oprot.writeStructEnd()
13910 
 
13911 
  def validate(self):
13912 
    return
13913 
 
13914 
 
13915 
  def __repr__(self):
13916 
    L = ['%s=%r' % (key, value)
13917 
      for key, value in self.__dict__.iteritems()]
13918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13919 
 
13920 
  def __eq__(self, other):
13921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13922 
 
13923 
  def __ne__(self, other):
13924 
    return not (self == other)
3956 chandransh 13925 
 
13926 
class reconcileCodCollection_args:
13927 
  """
13928 
  Attributes:
13929 
   - collectedAmountMap
13930 
   - xferBy
13931 
   - xferTxnId
13932 
   - xferDate
13933 
  """
13934 
 
13935 
  thrift_spec = (
13936 
    None, # 0
13937 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13938 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13939 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13940 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13941 
  )
13942 
 
13943 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13944 
    self.collectedAmountMap = collectedAmountMap
13945 
    self.xferBy = xferBy
13946 
    self.xferTxnId = xferTxnId
13947 
    self.xferDate = xferDate
13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 1:
13959 
        if ftype == TType.MAP:
13960 
          self.collectedAmountMap = {}
4133 chandransh 13961 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13962 
          for _i217 in xrange(_size213):
13963 
            _key218 = iprot.readString();
13964 
            _val219 = iprot.readDouble();
13965 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 13966 
          iprot.readMapEnd()
13967 
        else:
13968 
          iprot.skip(ftype)
13969 
      elif fid == 2:
13970 
        if ftype == TType.STRING:
13971 
          self.xferBy = iprot.readString();
13972 
        else:
13973 
          iprot.skip(ftype)
13974 
      elif fid == 3:
13975 
        if ftype == TType.STRING:
13976 
          self.xferTxnId = iprot.readString();
13977 
        else:
13978 
          iprot.skip(ftype)
13979 
      elif fid == 4:
13980 
        if ftype == TType.I64:
13981 
          self.xferDate = iprot.readI64();
13982 
        else:
13983 
          iprot.skip(ftype)
13984 
      else:
13985 
        iprot.skip(ftype)
13986 
      iprot.readFieldEnd()
13987 
    iprot.readStructEnd()
13988 
 
13989 
  def write(self, oprot):
13990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13992 
      return
13993 
    oprot.writeStructBegin('reconcileCodCollection_args')
13994 
    if self.collectedAmountMap is not None:
13995 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
13996 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 13997 
      for kiter220,viter221 in self.collectedAmountMap.items():
13998 
        oprot.writeString(kiter220)
13999 
        oprot.writeDouble(viter221)
3956 chandransh 14000 
      oprot.writeMapEnd()
14001 
      oprot.writeFieldEnd()
14002 
    if self.xferBy is not None:
14003 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14004 
      oprot.writeString(self.xferBy)
14005 
      oprot.writeFieldEnd()
14006 
    if self.xferTxnId is not None:
14007 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14008 
      oprot.writeString(self.xferTxnId)
14009 
      oprot.writeFieldEnd()
14010 
    if self.xferDate is not None:
14011 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14012 
      oprot.writeI64(self.xferDate)
14013 
      oprot.writeFieldEnd()
14014 
    oprot.writeFieldStop()
14015 
    oprot.writeStructEnd()
14016 
 
14017 
  def validate(self):
14018 
    return
14019 
 
14020 
 
14021 
  def __repr__(self):
14022 
    L = ['%s=%r' % (key, value)
14023 
      for key, value in self.__dict__.iteritems()]
14024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14025 
 
14026 
  def __eq__(self, other):
14027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14028 
 
14029 
  def __ne__(self, other):
14030 
    return not (self == other)
14031 
 
14032 
class reconcileCodCollection_result:
14033 
  """
14034 
  Attributes:
14035 
   - success
14036 
   - ex
14037 
  """
14038 
 
14039 
  thrift_spec = (
14040 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14042 
  )
14043 
 
14044 
  def __init__(self, success=None, ex=None,):
14045 
    self.success = success
14046 
    self.ex = ex
14047 
 
14048 
  def read(self, iprot):
14049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14051 
      return
14052 
    iprot.readStructBegin()
14053 
    while True:
14054 
      (fname, ftype, fid) = iprot.readFieldBegin()
14055 
      if ftype == TType.STOP:
14056 
        break
14057 
      if fid == 0:
14058 
        if ftype == TType.MAP:
14059 
          self.success = {}
4133 chandransh 14060 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
14061 
          for _i226 in xrange(_size222):
14062 
            _key227 = iprot.readString();
14063 
            _val228 = iprot.readString();
14064 
            self.success[_key227] = _val228
3956 chandransh 14065 
          iprot.readMapEnd()
14066 
        else:
14067 
          iprot.skip(ftype)
14068 
      elif fid == 1:
14069 
        if ftype == TType.STRUCT:
14070 
          self.ex = TransactionServiceException()
14071 
          self.ex.read(iprot)
14072 
        else:
14073 
          iprot.skip(ftype)
14074 
      else:
14075 
        iprot.skip(ftype)
14076 
      iprot.readFieldEnd()
14077 
    iprot.readStructEnd()
14078 
 
14079 
  def write(self, oprot):
14080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14082 
      return
14083 
    oprot.writeStructBegin('reconcileCodCollection_result')
14084 
    if self.success is not None:
14085 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14086 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 14087 
      for kiter229,viter230 in self.success.items():
14088 
        oprot.writeString(kiter229)
14089 
        oprot.writeString(viter230)
3956 chandransh 14090 
      oprot.writeMapEnd()
14091 
      oprot.writeFieldEnd()
14092 
    if self.ex is not None:
14093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14094 
      self.ex.write(oprot)
14095 
      oprot.writeFieldEnd()
14096 
    oprot.writeFieldStop()
14097 
    oprot.writeStructEnd()
14098 
 
14099 
  def validate(self):
14100 
    return
14101 
 
14102 
 
14103 
  def __repr__(self):
14104 
    L = ['%s=%r' % (key, value)
14105 
      for key, value in self.__dict__.iteritems()]
14106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14107 
 
14108 
  def __eq__(self, other):
14109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14110 
 
14111 
  def __ne__(self, other):
14112 
    return not (self == other)
4008 mandeep.dh 14113 
 
14114 
class getTransactionsRequiringExtraProcessing_args:
14115 
  """
14116 
  Attributes:
14117 
   - category
14118 
  """
14119 
 
14120 
  thrift_spec = (
14121 
    None, # 0
14122 
    (1, TType.I32, 'category', None, None, ), # 1
14123 
  )
14124 
 
14125 
  def __init__(self, category=None,):
14126 
    self.category = category
14127 
 
14128 
  def read(self, iprot):
14129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14131 
      return
14132 
    iprot.readStructBegin()
14133 
    while True:
14134 
      (fname, ftype, fid) = iprot.readFieldBegin()
14135 
      if ftype == TType.STOP:
14136 
        break
14137 
      if fid == 1:
14138 
        if ftype == TType.I32:
14139 
          self.category = iprot.readI32();
14140 
        else:
14141 
          iprot.skip(ftype)
14142 
      else:
14143 
        iprot.skip(ftype)
14144 
      iprot.readFieldEnd()
14145 
    iprot.readStructEnd()
14146 
 
14147 
  def write(self, oprot):
14148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14150 
      return
14151 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14152 
    if self.category is not None:
14153 
      oprot.writeFieldBegin('category', TType.I32, 1)
14154 
      oprot.writeI32(self.category)
14155 
      oprot.writeFieldEnd()
14156 
    oprot.writeFieldStop()
14157 
    oprot.writeStructEnd()
14158 
 
14159 
  def validate(self):
14160 
    return
14161 
 
14162 
 
14163 
  def __repr__(self):
14164 
    L = ['%s=%r' % (key, value)
14165 
      for key, value in self.__dict__.iteritems()]
14166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14167 
 
14168 
  def __eq__(self, other):
14169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14170 
 
14171 
  def __ne__(self, other):
14172 
    return not (self == other)
14173 
 
14174 
class getTransactionsRequiringExtraProcessing_result:
14175 
  """
14176 
  Attributes:
14177 
   - success
14178 
  """
14179 
 
14180 
  thrift_spec = (
14181 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14182 
  )
14183 
 
14184 
  def __init__(self, success=None,):
14185 
    self.success = success
14186 
 
14187 
  def read(self, iprot):
14188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14190 
      return
14191 
    iprot.readStructBegin()
14192 
    while True:
14193 
      (fname, ftype, fid) = iprot.readFieldBegin()
14194 
      if ftype == TType.STOP:
14195 
        break
14196 
      if fid == 0:
14197 
        if ftype == TType.LIST:
14198 
          self.success = []
4133 chandransh 14199 
          (_etype234, _size231) = iprot.readListBegin()
14200 
          for _i235 in xrange(_size231):
14201 
            _elem236 = iprot.readI64();
14202 
            self.success.append(_elem236)
4008 mandeep.dh 14203 
          iprot.readListEnd()
14204 
        else:
14205 
          iprot.skip(ftype)
14206 
      else:
14207 
        iprot.skip(ftype)
14208 
      iprot.readFieldEnd()
14209 
    iprot.readStructEnd()
14210 
 
14211 
  def write(self, oprot):
14212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14214 
      return
14215 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14216 
    if self.success is not None:
14217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14218 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 14219 
      for iter237 in self.success:
14220 
        oprot.writeI64(iter237)
4008 mandeep.dh 14221 
      oprot.writeListEnd()
14222 
      oprot.writeFieldEnd()
14223 
    oprot.writeFieldStop()
14224 
    oprot.writeStructEnd()
14225 
 
14226 
  def validate(self):
14227 
    return
14228 
 
14229 
 
14230 
  def __repr__(self):
14231 
    L = ['%s=%r' % (key, value)
14232 
      for key, value in self.__dict__.iteritems()]
14233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14234 
 
14235 
  def __eq__(self, other):
14236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14237 
 
14238 
  def __ne__(self, other):
14239 
    return not (self == other)
14240 
 
14241 
class markTransactionAsProcessed_args:
14242 
  """
14243 
  Attributes:
14244 
   - transactionId
14245 
   - category
14246 
  """
14247 
 
14248 
  thrift_spec = (
14249 
    None, # 0
14250 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14251 
    (2, TType.I32, 'category', None, None, ), # 2
14252 
  )
14253 
 
14254 
  def __init__(self, transactionId=None, category=None,):
14255 
    self.transactionId = transactionId
14256 
    self.category = category
14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      if fid == 1:
14268 
        if ftype == TType.I64:
14269 
          self.transactionId = iprot.readI64();
14270 
        else:
14271 
          iprot.skip(ftype)
14272 
      elif fid == 2:
14273 
        if ftype == TType.I32:
14274 
          self.category = iprot.readI32();
14275 
        else:
14276 
          iprot.skip(ftype)
14277 
      else:
14278 
        iprot.skip(ftype)
14279 
      iprot.readFieldEnd()
14280 
    iprot.readStructEnd()
14281 
 
14282 
  def write(self, oprot):
14283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14285 
      return
14286 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14287 
    if self.transactionId is not None:
14288 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14289 
      oprot.writeI64(self.transactionId)
14290 
      oprot.writeFieldEnd()
14291 
    if self.category is not None:
14292 
      oprot.writeFieldBegin('category', TType.I32, 2)
14293 
      oprot.writeI32(self.category)
14294 
      oprot.writeFieldEnd()
14295 
    oprot.writeFieldStop()
14296 
    oprot.writeStructEnd()
14297 
 
14298 
  def validate(self):
14299 
    return
14300 
 
14301 
 
14302 
  def __repr__(self):
14303 
    L = ['%s=%r' % (key, value)
14304 
      for key, value in self.__dict__.iteritems()]
14305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14306 
 
14307 
  def __eq__(self, other):
14308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14309 
 
14310 
  def __ne__(self, other):
14311 
    return not (self == other)
14312 
 
14313 
class markTransactionAsProcessed_result:
14314 
 
14315 
  thrift_spec = (
14316 
  )
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 
      else:
14328 
        iprot.skip(ftype)
14329 
      iprot.readFieldEnd()
14330 
    iprot.readStructEnd()
14331 
 
14332 
  def write(self, oprot):
14333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14335 
      return
14336 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14337 
    oprot.writeFieldStop()
14338 
    oprot.writeStructEnd()
14339 
 
14340 
  def validate(self):
14341 
    return
14342 
 
14343 
 
14344 
  def __repr__(self):
14345 
    L = ['%s=%r' % (key, value)
14346 
      for key, value in self.__dict__.iteritems()]
14347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14348 
 
14349 
  def __eq__(self, other):
14350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14351 
 
14352 
  def __ne__(self, other):
14353 
    return not (self == other)
4018 chandransh 14354 
 
14355 
class getItemWiseRiskyOrdersCount_args:
14356 
 
14357 
  thrift_spec = (
14358 
  )
14359 
 
14360 
  def read(self, iprot):
14361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14363 
      return
14364 
    iprot.readStructBegin()
14365 
    while True:
14366 
      (fname, ftype, fid) = iprot.readFieldBegin()
14367 
      if ftype == TType.STOP:
14368 
        break
14369 
      else:
14370 
        iprot.skip(ftype)
14371 
      iprot.readFieldEnd()
14372 
    iprot.readStructEnd()
14373 
 
14374 
  def write(self, oprot):
14375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14377 
      return
14378 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14379 
    oprot.writeFieldStop()
14380 
    oprot.writeStructEnd()
14381 
 
14382 
  def validate(self):
14383 
    return
14384 
 
14385 
 
14386 
  def __repr__(self):
14387 
    L = ['%s=%r' % (key, value)
14388 
      for key, value in self.__dict__.iteritems()]
14389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14390 
 
14391 
  def __eq__(self, other):
14392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14393 
 
14394 
  def __ne__(self, other):
14395 
    return not (self == other)
14396 
 
14397 
class getItemWiseRiskyOrdersCount_result:
14398 
  """
14399 
  Attributes:
14400 
   - success
14401 
  """
14402 
 
14403 
  thrift_spec = (
14404 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14405 
  )
14406 
 
14407 
  def __init__(self, success=None,):
14408 
    self.success = success
14409 
 
14410 
  def read(self, iprot):
14411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14413 
      return
14414 
    iprot.readStructBegin()
14415 
    while True:
14416 
      (fname, ftype, fid) = iprot.readFieldBegin()
14417 
      if ftype == TType.STOP:
14418 
        break
14419 
      if fid == 0:
14420 
        if ftype == TType.MAP:
14421 
          self.success = {}
4133 chandransh 14422 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
14423 
          for _i242 in xrange(_size238):
14424 
            _key243 = iprot.readI64();
14425 
            _val244 = iprot.readI64();
14426 
            self.success[_key243] = _val244
4018 chandransh 14427 
          iprot.readMapEnd()
14428 
        else:
14429 
          iprot.skip(ftype)
14430 
      else:
14431 
        iprot.skip(ftype)
14432 
      iprot.readFieldEnd()
14433 
    iprot.readStructEnd()
14434 
 
14435 
  def write(self, oprot):
14436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14438 
      return
14439 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14440 
    if self.success is not None:
14441 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14442 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 14443 
      for kiter245,viter246 in self.success.items():
14444 
        oprot.writeI64(kiter245)
14445 
        oprot.writeI64(viter246)
4018 chandransh 14446 
      oprot.writeMapEnd()
14447 
      oprot.writeFieldEnd()
14448 
    oprot.writeFieldStop()
14449 
    oprot.writeStructEnd()
14450 
 
14451 
  def validate(self):
14452 
    return
14453 
 
14454 
 
14455 
  def __repr__(self):
14456 
    L = ['%s=%r' % (key, value)
14457 
      for key, value in self.__dict__.iteritems()]
14458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14459 
 
14460 
  def __eq__(self, other):
14461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14462 
 
14463 
  def __ne__(self, other):
14464 
    return not (self == other)
4247 rajveer 14465 
 
4295 varun.gupt 14466 
class getOrdersForItemIds_args:
14467 
  """
14468 
  Attributes:
14469 
   - itemIds
14470 
  """
14471 
 
14472 
  thrift_spec = (
14473 
    None, # 0
14474 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14475 
  )
14476 
 
14477 
  def __init__(self, itemIds=None,):
14478 
    self.itemIds = itemIds
14479 
 
14480 
  def read(self, iprot):
14481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14483 
      return
14484 
    iprot.readStructBegin()
14485 
    while True:
14486 
      (fname, ftype, fid) = iprot.readFieldBegin()
14487 
      if ftype == TType.STOP:
14488 
        break
14489 
      if fid == 1:
14490 
        if ftype == TType.LIST:
14491 
          self.itemIds = []
14492 
          (_etype250, _size247) = iprot.readListBegin()
14493 
          for _i251 in xrange(_size247):
14494 
            _elem252 = iprot.readI64();
14495 
            self.itemIds.append(_elem252)
14496 
          iprot.readListEnd()
14497 
        else:
14498 
          iprot.skip(ftype)
14499 
      else:
14500 
        iprot.skip(ftype)
14501 
      iprot.readFieldEnd()
14502 
    iprot.readStructEnd()
14503 
 
14504 
  def write(self, oprot):
14505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14507 
      return
14508 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14509 
    if self.itemIds is not None:
14510 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14511 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
14512 
      for iter253 in self.itemIds:
14513 
        oprot.writeI64(iter253)
14514 
      oprot.writeListEnd()
14515 
      oprot.writeFieldEnd()
14516 
    oprot.writeFieldStop()
14517 
    oprot.writeStructEnd()
14518 
 
14519 
  def validate(self):
14520 
    return
14521 
 
14522 
 
14523 
  def __repr__(self):
14524 
    L = ['%s=%r' % (key, value)
14525 
      for key, value in self.__dict__.iteritems()]
14526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14527 
 
14528 
  def __eq__(self, other):
14529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14530 
 
14531 
  def __ne__(self, other):
14532 
    return not (self == other)
14533 
 
14534 
class getOrdersForItemIds_result:
14535 
  """
14536 
  Attributes:
14537 
   - success
14538 
  """
14539 
 
14540 
  thrift_spec = (
14541 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14542 
  )
14543 
 
14544 
  def __init__(self, success=None,):
14545 
    self.success = success
14546 
 
14547 
  def read(self, iprot):
14548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14550 
      return
14551 
    iprot.readStructBegin()
14552 
    while True:
14553 
      (fname, ftype, fid) = iprot.readFieldBegin()
14554 
      if ftype == TType.STOP:
14555 
        break
14556 
      if fid == 0:
14557 
        if ftype == TType.LIST:
14558 
          self.success = []
14559 
          (_etype257, _size254) = iprot.readListBegin()
14560 
          for _i258 in xrange(_size254):
14561 
            _elem259 = Order()
14562 
            _elem259.read(iprot)
14563 
            self.success.append(_elem259)
14564 
          iprot.readListEnd()
14565 
        else:
14566 
          iprot.skip(ftype)
14567 
      else:
14568 
        iprot.skip(ftype)
14569 
      iprot.readFieldEnd()
14570 
    iprot.readStructEnd()
14571 
 
14572 
  def write(self, oprot):
14573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14575 
      return
14576 
    oprot.writeStructBegin('getOrdersForItemIds_result')
14577 
    if self.success is not None:
14578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14579 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
14580 
      for iter260 in self.success:
14581 
        iter260.write(oprot)
14582 
      oprot.writeListEnd()
14583 
      oprot.writeFieldEnd()
14584 
    oprot.writeFieldStop()
14585 
    oprot.writeStructEnd()
14586 
 
14587 
  def validate(self):
14588 
    return
14589 
 
14590 
 
14591 
  def __repr__(self):
14592 
    L = ['%s=%r' % (key, value)
14593 
      for key, value in self.__dict__.iteritems()]
14594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14595 
 
14596 
  def __eq__(self, other):
14597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14598 
 
14599 
  def __ne__(self, other):
14600 
    return not (self == other)
14601 
 
4247 rajveer 14602 
class markOrderCancellationRequestReceived_args:
14603 
  """
14604 
  Attributes:
14605 
   - orderId
14606 
  """
14607 
 
14608 
  thrift_spec = (
14609 
    None, # 0
14610 
    (1, TType.I64, 'orderId', None, None, ), # 1
14611 
  )
14612 
 
14613 
  def __init__(self, orderId=None,):
14614 
    self.orderId = orderId
14615 
 
14616 
  def read(self, iprot):
14617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14619 
      return
14620 
    iprot.readStructBegin()
14621 
    while True:
14622 
      (fname, ftype, fid) = iprot.readFieldBegin()
14623 
      if ftype == TType.STOP:
14624 
        break
14625 
      if fid == 1:
14626 
        if ftype == TType.I64:
14627 
          self.orderId = iprot.readI64();
14628 
        else:
14629 
          iprot.skip(ftype)
14630 
      else:
14631 
        iprot.skip(ftype)
14632 
      iprot.readFieldEnd()
14633 
    iprot.readStructEnd()
14634 
 
14635 
  def write(self, oprot):
14636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14638 
      return
14639 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
14640 
    if self.orderId is not None:
14641 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14642 
      oprot.writeI64(self.orderId)
14643 
      oprot.writeFieldEnd()
14644 
    oprot.writeFieldStop()
14645 
    oprot.writeStructEnd()
14646 
 
14647 
  def validate(self):
14648 
    return
14649 
 
14650 
 
14651 
  def __repr__(self):
14652 
    L = ['%s=%r' % (key, value)
14653 
      for key, value in self.__dict__.iteritems()]
14654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14655 
 
14656 
  def __eq__(self, other):
14657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14658 
 
14659 
  def __ne__(self, other):
14660 
    return not (self == other)
14661 
 
14662 
class markOrderCancellationRequestReceived_result:
14663 
  """
14664 
  Attributes:
14665 
   - ex
14666 
  """
14667 
 
14668 
  thrift_spec = (
14669 
    None, # 0
14670 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14671 
  )
14672 
 
14673 
  def __init__(self, ex=None,):
14674 
    self.ex = ex
14675 
 
14676 
  def read(self, iprot):
14677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14679 
      return
14680 
    iprot.readStructBegin()
14681 
    while True:
14682 
      (fname, ftype, fid) = iprot.readFieldBegin()
14683 
      if ftype == TType.STOP:
14684 
        break
14685 
      if fid == 1:
14686 
        if ftype == TType.STRUCT:
14687 
          self.ex = TransactionServiceException()
14688 
          self.ex.read(iprot)
14689 
        else:
14690 
          iprot.skip(ftype)
14691 
      else:
14692 
        iprot.skip(ftype)
14693 
      iprot.readFieldEnd()
14694 
    iprot.readStructEnd()
14695 
 
14696 
  def write(self, oprot):
14697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14699 
      return
14700 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
14701 
    if self.ex is not None:
14702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14703 
      self.ex.write(oprot)
14704 
      oprot.writeFieldEnd()
14705 
    oprot.writeFieldStop()
14706 
    oprot.writeStructEnd()
14707 
 
14708 
  def validate(self):
14709 
    return
14710 
 
14711 
 
14712 
  def __repr__(self):
14713 
    L = ['%s=%r' % (key, value)
14714 
      for key, value in self.__dict__.iteritems()]
14715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14716 
 
14717 
  def __eq__(self, other):
14718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14719 
 
14720 
  def __ne__(self, other):
14721 
    return not (self == other)
14722 
 
14723 
class markOrderCancellationRequestConfirmed_args:
14724 
  """
14725 
  Attributes:
14726 
   - orderId
14727 
  """
14728 
 
14729 
  thrift_spec = (
14730 
    None, # 0
14731 
    (1, TType.I64, 'orderId', None, None, ), # 1
14732 
  )
14733 
 
14734 
  def __init__(self, orderId=None,):
14735 
    self.orderId = orderId
14736 
 
14737 
  def read(self, iprot):
14738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14740 
      return
14741 
    iprot.readStructBegin()
14742 
    while True:
14743 
      (fname, ftype, fid) = iprot.readFieldBegin()
14744 
      if ftype == TType.STOP:
14745 
        break
14746 
      if fid == 1:
14747 
        if ftype == TType.I64:
14748 
          self.orderId = iprot.readI64();
14749 
        else:
14750 
          iprot.skip(ftype)
14751 
      else:
14752 
        iprot.skip(ftype)
14753 
      iprot.readFieldEnd()
14754 
    iprot.readStructEnd()
14755 
 
14756 
  def write(self, oprot):
14757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14759 
      return
14760 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
14761 
    if self.orderId is not None:
14762 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14763 
      oprot.writeI64(self.orderId)
14764 
      oprot.writeFieldEnd()
14765 
    oprot.writeFieldStop()
14766 
    oprot.writeStructEnd()
14767 
 
14768 
  def validate(self):
14769 
    return
14770 
 
14771 
 
14772 
  def __repr__(self):
14773 
    L = ['%s=%r' % (key, value)
14774 
      for key, value in self.__dict__.iteritems()]
14775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14776 
 
14777 
  def __eq__(self, other):
14778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14779 
 
14780 
  def __ne__(self, other):
14781 
    return not (self == other)
14782 
 
14783 
class markOrderCancellationRequestConfirmed_result:
14784 
  """
14785 
  Attributes:
14786 
   - ex
14787 
  """
14788 
 
14789 
  thrift_spec = (
14790 
    None, # 0
14791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14792 
  )
14793 
 
14794 
  def __init__(self, ex=None,):
14795 
    self.ex = ex
14796 
 
14797 
  def read(self, iprot):
14798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14800 
      return
14801 
    iprot.readStructBegin()
14802 
    while True:
14803 
      (fname, ftype, fid) = iprot.readFieldBegin()
14804 
      if ftype == TType.STOP:
14805 
        break
14806 
      if fid == 1:
14807 
        if ftype == TType.STRUCT:
14808 
          self.ex = TransactionServiceException()
14809 
          self.ex.read(iprot)
14810 
        else:
14811 
          iprot.skip(ftype)
14812 
      else:
14813 
        iprot.skip(ftype)
14814 
      iprot.readFieldEnd()
14815 
    iprot.readStructEnd()
14816 
 
14817 
  def write(self, oprot):
14818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14820 
      return
14821 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
14822 
    if self.ex is not None:
14823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14824 
      self.ex.write(oprot)
14825 
      oprot.writeFieldEnd()
14826 
    oprot.writeFieldStop()
14827 
    oprot.writeStructEnd()
14828 
 
14829 
  def validate(self):
14830 
    return
14831 
 
14832 
 
14833 
  def __repr__(self):
14834 
    L = ['%s=%r' % (key, value)
14835 
      for key, value in self.__dict__.iteritems()]
14836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14837 
 
14838 
  def __eq__(self, other):
14839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14840 
 
14841 
  def __ne__(self, other):
14842 
    return not (self == other)
14843 
 
14844 
class markOrderCancellationRequestDenied_args:
14845 
  """
14846 
  Attributes:
14847 
   - orderId
14848 
  """
14849 
 
14850 
  thrift_spec = (
14851 
    None, # 0
14852 
    (1, TType.I64, 'orderId', None, None, ), # 1
14853 
  )
14854 
 
14855 
  def __init__(self, orderId=None,):
14856 
    self.orderId = orderId
14857 
 
14858 
  def read(self, iprot):
14859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14861 
      return
14862 
    iprot.readStructBegin()
14863 
    while True:
14864 
      (fname, ftype, fid) = iprot.readFieldBegin()
14865 
      if ftype == TType.STOP:
14866 
        break
14867 
      if fid == 1:
14868 
        if ftype == TType.I64:
14869 
          self.orderId = iprot.readI64();
14870 
        else:
14871 
          iprot.skip(ftype)
14872 
      else:
14873 
        iprot.skip(ftype)
14874 
      iprot.readFieldEnd()
14875 
    iprot.readStructEnd()
14876 
 
14877 
  def write(self, oprot):
14878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14880 
      return
14881 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14882 
    if self.orderId is not None:
14883 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14884 
      oprot.writeI64(self.orderId)
14885 
      oprot.writeFieldEnd()
14886 
    oprot.writeFieldStop()
14887 
    oprot.writeStructEnd()
14888 
 
14889 
  def validate(self):
14890 
    return
14891 
 
14892 
 
14893 
  def __repr__(self):
14894 
    L = ['%s=%r' % (key, value)
14895 
      for key, value in self.__dict__.iteritems()]
14896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14897 
 
14898 
  def __eq__(self, other):
14899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14900 
 
14901 
  def __ne__(self, other):
14902 
    return not (self == other)
14903 
 
14904 
class markOrderCancellationRequestDenied_result:
14905 
  """
14906 
  Attributes:
14907 
   - ex
14908 
  """
14909 
 
14910 
  thrift_spec = (
14911 
    None, # 0
14912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14913 
  )
14914 
 
14915 
  def __init__(self, ex=None,):
14916 
    self.ex = ex
14917 
 
14918 
  def read(self, iprot):
14919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14921 
      return
14922 
    iprot.readStructBegin()
14923 
    while True:
14924 
      (fname, ftype, fid) = iprot.readFieldBegin()
14925 
      if ftype == TType.STOP:
14926 
        break
14927 
      if fid == 1:
14928 
        if ftype == TType.STRUCT:
14929 
          self.ex = TransactionServiceException()
14930 
          self.ex.read(iprot)
14931 
        else:
14932 
          iprot.skip(ftype)
14933 
      else:
14934 
        iprot.skip(ftype)
14935 
      iprot.readFieldEnd()
14936 
    iprot.readStructEnd()
14937 
 
14938 
  def write(self, oprot):
14939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14941 
      return
14942 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14943 
    if self.ex is not None:
14944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14945 
      self.ex.write(oprot)
14946 
      oprot.writeFieldEnd()
14947 
    oprot.writeFieldStop()
14948 
    oprot.writeStructEnd()
14949 
 
14950 
  def validate(self):
14951 
    return
14952 
 
14953 
 
14954 
  def __repr__(self):
14955 
    L = ['%s=%r' % (key, value)
14956 
      for key, value in self.__dict__.iteritems()]
14957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14958 
 
14959 
  def __eq__(self, other):
14960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14961 
 
14962 
  def __ne__(self, other):
14963 
    return not (self == other)
14964 
 
4258 rajveer 14965 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14966 
  """
14967 
  Attributes:
4258 rajveer 14968 
   - transactionId
4247 rajveer 14969 
  """
14970 
 
14971 
  thrift_spec = (
14972 
    None, # 0
4258 rajveer 14973 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14974 
  )
14975 
 
4258 rajveer 14976 
  def __init__(self, transactionId=None,):
14977 
    self.transactionId = transactionId
4247 rajveer 14978 
 
14979 
  def read(self, iprot):
14980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14982 
      return
14983 
    iprot.readStructBegin()
14984 
    while True:
14985 
      (fname, ftype, fid) = iprot.readFieldBegin()
14986 
      if ftype == TType.STOP:
14987 
        break
14988 
      if fid == 1:
14989 
        if ftype == TType.I64:
4258 rajveer 14990 
          self.transactionId = iprot.readI64();
4247 rajveer 14991 
        else:
14992 
          iprot.skip(ftype)
14993 
      else:
14994 
        iprot.skip(ftype)
14995 
      iprot.readFieldEnd()
14996 
    iprot.readStructEnd()
14997 
 
14998 
  def write(self, oprot):
14999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15001 
      return
4258 rajveer 15002 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15003 
    if self.transactionId is not None:
15004 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15005 
      oprot.writeI64(self.transactionId)
4247 rajveer 15006 
      oprot.writeFieldEnd()
15007 
    oprot.writeFieldStop()
15008 
    oprot.writeStructEnd()
15009 
 
15010 
  def validate(self):
15011 
    return
15012 
 
15013 
 
15014 
  def __repr__(self):
15015 
    L = ['%s=%r' % (key, value)
15016 
      for key, value in self.__dict__.iteritems()]
15017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15018 
 
15019 
  def __eq__(self, other):
15020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15021 
 
15022 
  def __ne__(self, other):
15023 
    return not (self == other)
15024 
 
4258 rajveer 15025 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15026 
  """
15027 
  Attributes:
15028 
   - ex
15029 
  """
15030 
 
15031 
  thrift_spec = (
15032 
    None, # 0
15033 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15034 
  )
15035 
 
15036 
  def __init__(self, ex=None,):
15037 
    self.ex = ex
15038 
 
15039 
  def read(self, iprot):
15040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15042 
      return
15043 
    iprot.readStructBegin()
15044 
    while True:
15045 
      (fname, ftype, fid) = iprot.readFieldBegin()
15046 
      if ftype == TType.STOP:
15047 
        break
15048 
      if fid == 1:
15049 
        if ftype == TType.STRUCT:
15050 
          self.ex = TransactionServiceException()
15051 
          self.ex.read(iprot)
15052 
        else:
15053 
          iprot.skip(ftype)
15054 
      else:
15055 
        iprot.skip(ftype)
15056 
      iprot.readFieldEnd()
15057 
    iprot.readStructEnd()
15058 
 
15059 
  def write(self, oprot):
15060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15062 
      return
4258 rajveer 15063 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15064 
    if self.ex is not None:
15065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15066 
      self.ex.write(oprot)
15067 
      oprot.writeFieldEnd()
15068 
    oprot.writeFieldStop()
15069 
    oprot.writeStructEnd()
15070 
 
15071 
  def validate(self):
15072 
    return
15073 
 
15074 
 
15075 
  def __repr__(self):
15076 
    L = ['%s=%r' % (key, value)
15077 
      for key, value in self.__dict__.iteritems()]
15078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15079 
 
15080 
  def __eq__(self, other):
15081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15082 
 
15083 
  def __ne__(self, other):
15084 
    return not (self == other)
4259 anupam.sin 15085 
 
15086 
class refundTransaction_args:
15087 
  """
15088 
  Attributes:
15089 
   - transactionId
15090 
   - refundedBy
15091 
   - reason
15092 
  """
15093 
 
15094 
  thrift_spec = (
15095 
    None, # 0
15096 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15097 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15098 
    (3, TType.STRING, 'reason', None, None, ), # 3
15099 
  )
15100 
 
15101 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15102 
    self.transactionId = transactionId
15103 
    self.refundedBy = refundedBy
15104 
    self.reason = reason
15105 
 
15106 
  def read(self, iprot):
15107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15109 
      return
15110 
    iprot.readStructBegin()
15111 
    while True:
15112 
      (fname, ftype, fid) = iprot.readFieldBegin()
15113 
      if ftype == TType.STOP:
15114 
        break
15115 
      if fid == 1:
15116 
        if ftype == TType.I64:
15117 
          self.transactionId = iprot.readI64();
15118 
        else:
15119 
          iprot.skip(ftype)
15120 
      elif fid == 2:
15121 
        if ftype == TType.STRING:
15122 
          self.refundedBy = iprot.readString();
15123 
        else:
15124 
          iprot.skip(ftype)
15125 
      elif fid == 3:
15126 
        if ftype == TType.STRING:
15127 
          self.reason = iprot.readString();
15128 
        else:
15129 
          iprot.skip(ftype)
15130 
      else:
15131 
        iprot.skip(ftype)
15132 
      iprot.readFieldEnd()
15133 
    iprot.readStructEnd()
15134 
 
15135 
  def write(self, oprot):
15136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15138 
      return
15139 
    oprot.writeStructBegin('refundTransaction_args')
15140 
    if self.transactionId is not None:
15141 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15142 
      oprot.writeI64(self.transactionId)
15143 
      oprot.writeFieldEnd()
15144 
    if self.refundedBy is not None:
15145 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15146 
      oprot.writeString(self.refundedBy)
15147 
      oprot.writeFieldEnd()
15148 
    if self.reason is not None:
15149 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15150 
      oprot.writeString(self.reason)
15151 
      oprot.writeFieldEnd()
15152 
    oprot.writeFieldStop()
15153 
    oprot.writeStructEnd()
15154 
 
15155 
  def validate(self):
15156 
    return
15157 
 
15158 
 
15159 
  def __repr__(self):
15160 
    L = ['%s=%r' % (key, value)
15161 
      for key, value in self.__dict__.iteritems()]
15162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15163 
 
15164 
  def __eq__(self, other):
15165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15166 
 
15167 
  def __ne__(self, other):
15168 
    return not (self == other)
15169 
 
15170 
class refundTransaction_result:
15171 
  """
15172 
  Attributes:
15173 
   - ex
15174 
  """
15175 
 
15176 
  thrift_spec = (
15177 
    None, # 0
15178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15179 
  )
15180 
 
15181 
  def __init__(self, ex=None,):
15182 
    self.ex = ex
15183 
 
15184 
  def read(self, iprot):
15185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15187 
      return
15188 
    iprot.readStructBegin()
15189 
    while True:
15190 
      (fname, ftype, fid) = iprot.readFieldBegin()
15191 
      if ftype == TType.STOP:
15192 
        break
15193 
      if fid == 1:
15194 
        if ftype == TType.STRUCT:
15195 
          self.ex = TransactionServiceException()
15196 
          self.ex.read(iprot)
15197 
        else:
15198 
          iprot.skip(ftype)
15199 
      else:
15200 
        iprot.skip(ftype)
15201 
      iprot.readFieldEnd()
15202 
    iprot.readStructEnd()
15203 
 
15204 
  def write(self, oprot):
15205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15207 
      return
15208 
    oprot.writeStructBegin('refundTransaction_result')
15209 
    if self.ex is not None:
15210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15211 
      self.ex.write(oprot)
15212 
      oprot.writeFieldEnd()
15213 
    oprot.writeFieldStop()
15214 
    oprot.writeStructEnd()
15215 
 
15216 
  def validate(self):
15217 
    return
15218 
 
15219 
 
15220 
  def __repr__(self):
15221 
    L = ['%s=%r' % (key, value)
15222 
      for key, value in self.__dict__.iteritems()]
15223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15224 
 
15225 
  def __eq__(self, other):
15226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15227 
 
15228 
  def __ne__(self, other):
15229 
    return not (self == other)
4285 rajveer 15230 
 
4324 mandeep.dh 15231 
class updateShipmentAddress_args:
15232 
  """
15233 
  Attributes:
15234 
   - orderId
15235 
   - addressId
15236 
  """
15237 
 
15238 
  thrift_spec = (
15239 
    None, # 0
15240 
    (1, TType.I64, 'orderId', None, None, ), # 1
15241 
    (2, TType.I64, 'addressId', None, None, ), # 2
15242 
  )
15243 
 
15244 
  def __init__(self, orderId=None, addressId=None,):
15245 
    self.orderId = orderId
15246 
    self.addressId = addressId
15247 
 
15248 
  def read(self, iprot):
15249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15251 
      return
15252 
    iprot.readStructBegin()
15253 
    while True:
15254 
      (fname, ftype, fid) = iprot.readFieldBegin()
15255 
      if ftype == TType.STOP:
15256 
        break
15257 
      if fid == 1:
15258 
        if ftype == TType.I64:
15259 
          self.orderId = iprot.readI64();
15260 
        else:
15261 
          iprot.skip(ftype)
15262 
      elif fid == 2:
15263 
        if ftype == TType.I64:
15264 
          self.addressId = iprot.readI64();
15265 
        else:
15266 
          iprot.skip(ftype)
15267 
      else:
15268 
        iprot.skip(ftype)
15269 
      iprot.readFieldEnd()
15270 
    iprot.readStructEnd()
15271 
 
15272 
  def write(self, oprot):
15273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15275 
      return
15276 
    oprot.writeStructBegin('updateShipmentAddress_args')
15277 
    if self.orderId is not None:
15278 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15279 
      oprot.writeI64(self.orderId)
15280 
      oprot.writeFieldEnd()
15281 
    if self.addressId is not None:
15282 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15283 
      oprot.writeI64(self.addressId)
15284 
      oprot.writeFieldEnd()
15285 
    oprot.writeFieldStop()
15286 
    oprot.writeStructEnd()
15287 
 
15288 
  def validate(self):
15289 
    return
15290 
 
15291 
 
15292 
  def __repr__(self):
15293 
    L = ['%s=%r' % (key, value)
15294 
      for key, value in self.__dict__.iteritems()]
15295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15296 
 
15297 
  def __eq__(self, other):
15298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15299 
 
15300 
  def __ne__(self, other):
15301 
    return not (self == other)
15302 
 
15303 
class updateShipmentAddress_result:
15304 
  """
15305 
  Attributes:
15306 
   - ex
15307 
  """
15308 
 
15309 
  thrift_spec = (
15310 
    None, # 0
15311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15312 
  )
15313 
 
15314 
  def __init__(self, ex=None,):
15315 
    self.ex = ex
15316 
 
15317 
  def read(self, iprot):
15318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15320 
      return
15321 
    iprot.readStructBegin()
15322 
    while True:
15323 
      (fname, ftype, fid) = iprot.readFieldBegin()
15324 
      if ftype == TType.STOP:
15325 
        break
15326 
      if fid == 1:
15327 
        if ftype == TType.STRUCT:
15328 
          self.ex = TransactionServiceException()
15329 
          self.ex.read(iprot)
15330 
        else:
15331 
          iprot.skip(ftype)
15332 
      else:
15333 
        iprot.skip(ftype)
15334 
      iprot.readFieldEnd()
15335 
    iprot.readStructEnd()
15336 
 
15337 
  def write(self, oprot):
15338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15340 
      return
15341 
    oprot.writeStructBegin('updateShipmentAddress_result')
15342 
    if self.ex is not None:
15343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15344 
      self.ex.write(oprot)
15345 
      oprot.writeFieldEnd()
15346 
    oprot.writeFieldStop()
15347 
    oprot.writeStructEnd()
15348 
 
15349 
  def validate(self):
15350 
    return
15351 
 
15352 
 
15353 
  def __repr__(self):
15354 
    L = ['%s=%r' % (key, value)
15355 
      for key, value in self.__dict__.iteritems()]
15356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15357 
 
15358 
  def __eq__(self, other):
15359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15360 
 
15361 
  def __ne__(self, other):
15362 
    return not (self == other)
15363 
 
4285 rajveer 15364 
class acceptOrdersForItemId_args:
15365 
  """
15366 
  Attributes:
15367 
   - itemId
15368 
   - inventory
15369 
  """
15370 
 
15371 
  thrift_spec = (
15372 
    None, # 0
15373 
    (1, TType.I64, 'itemId', None, None, ), # 1
15374 
    (2, TType.I64, 'inventory', None, None, ), # 2
15375 
  )
15376 
 
15377 
  def __init__(self, itemId=None, inventory=None,):
15378 
    self.itemId = itemId
15379 
    self.inventory = inventory
15380 
 
15381 
  def read(self, iprot):
15382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15384 
      return
15385 
    iprot.readStructBegin()
15386 
    while True:
15387 
      (fname, ftype, fid) = iprot.readFieldBegin()
15388 
      if ftype == TType.STOP:
15389 
        break
15390 
      if fid == 1:
15391 
        if ftype == TType.I64:
15392 
          self.itemId = iprot.readI64();
15393 
        else:
15394 
          iprot.skip(ftype)
15395 
      elif fid == 2:
15396 
        if ftype == TType.I64:
15397 
          self.inventory = iprot.readI64();
15398 
        else:
15399 
          iprot.skip(ftype)
15400 
      else:
15401 
        iprot.skip(ftype)
15402 
      iprot.readFieldEnd()
15403 
    iprot.readStructEnd()
15404 
 
15405 
  def write(self, oprot):
15406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15408 
      return
15409 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15410 
    if self.itemId is not None:
15411 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15412 
      oprot.writeI64(self.itemId)
15413 
      oprot.writeFieldEnd()
15414 
    if self.inventory is not None:
15415 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15416 
      oprot.writeI64(self.inventory)
15417 
      oprot.writeFieldEnd()
15418 
    oprot.writeFieldStop()
15419 
    oprot.writeStructEnd()
15420 
 
15421 
  def validate(self):
15422 
    return
15423 
 
15424 
 
15425 
  def __repr__(self):
15426 
    L = ['%s=%r' % (key, value)
15427 
      for key, value in self.__dict__.iteritems()]
15428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15429 
 
15430 
  def __eq__(self, other):
15431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15432 
 
15433 
  def __ne__(self, other):
15434 
    return not (self == other)
15435 
 
15436 
class acceptOrdersForItemId_result:
15437 
  """
15438 
  Attributes:
15439 
   - success
15440 
   - ex
15441 
  """
15442 
 
15443 
  thrift_spec = (
15444 
    (0, TType.BOOL, 'success', None, None, ), # 0
15445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15446 
  )
15447 
 
15448 
  def __init__(self, success=None, ex=None,):
15449 
    self.success = success
15450 
    self.ex = ex
15451 
 
15452 
  def read(self, iprot):
15453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15455 
      return
15456 
    iprot.readStructBegin()
15457 
    while True:
15458 
      (fname, ftype, fid) = iprot.readFieldBegin()
15459 
      if ftype == TType.STOP:
15460 
        break
15461 
      if fid == 0:
15462 
        if ftype == TType.BOOL:
15463 
          self.success = iprot.readBool();
15464 
        else:
15465 
          iprot.skip(ftype)
15466 
      elif fid == 1:
15467 
        if ftype == TType.STRUCT:
15468 
          self.ex = TransactionServiceException()
15469 
          self.ex.read(iprot)
15470 
        else:
15471 
          iprot.skip(ftype)
15472 
      else:
15473 
        iprot.skip(ftype)
15474 
      iprot.readFieldEnd()
15475 
    iprot.readStructEnd()
15476 
 
15477 
  def write(self, oprot):
15478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15480 
      return
15481 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15482 
    if self.success is not None:
15483 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15484 
      oprot.writeBool(self.success)
15485 
      oprot.writeFieldEnd()
15486 
    if self.ex is not None:
15487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15488 
      self.ex.write(oprot)
15489 
      oprot.writeFieldEnd()
15490 
    oprot.writeFieldStop()
15491 
    oprot.writeStructEnd()
15492 
 
15493 
  def validate(self):
15494 
    return
15495 
 
15496 
 
15497 
  def __repr__(self):
15498 
    L = ['%s=%r' % (key, value)
15499 
      for key, value in self.__dict__.iteritems()]
15500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15501 
 
15502 
  def __eq__(self, other):
15503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15504 
 
15505 
  def __ne__(self, other):
15506 
    return not (self == other)
4303 rajveer 15507 
 
15508 
class markOrdersAsPORaised_args:
15509 
  """
15510 
  Attributes:
15511 
   - vendorId
15512 
   - itemId
15513 
   - quantity
15514 
   - estimate
4369 rajveer 15515 
   - isReminder
4303 rajveer 15516 
  """
15517 
 
15518 
  thrift_spec = (
15519 
    None, # 0
15520 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15521 
    (2, TType.I64, 'itemId', None, None, ), # 2
15522 
    (3, TType.I64, 'quantity', None, None, ), # 3
15523 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15524 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15525 
  )
15526 
 
4369 rajveer 15527 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15528 
    self.vendorId = vendorId
15529 
    self.itemId = itemId
15530 
    self.quantity = quantity
15531 
    self.estimate = estimate
4369 rajveer 15532 
    self.isReminder = isReminder
4303 rajveer 15533 
 
15534 
  def read(self, iprot):
15535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15537 
      return
15538 
    iprot.readStructBegin()
15539 
    while True:
15540 
      (fname, ftype, fid) = iprot.readFieldBegin()
15541 
      if ftype == TType.STOP:
15542 
        break
15543 
      if fid == 1:
15544 
        if ftype == TType.I64:
15545 
          self.vendorId = iprot.readI64();
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      elif fid == 2:
15549 
        if ftype == TType.I64:
15550 
          self.itemId = iprot.readI64();
15551 
        else:
15552 
          iprot.skip(ftype)
15553 
      elif fid == 3:
15554 
        if ftype == TType.I64:
15555 
          self.quantity = iprot.readI64();
15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      elif fid == 4:
15559 
        if ftype == TType.I64:
15560 
          self.estimate = iprot.readI64();
15561 
        else:
15562 
          iprot.skip(ftype)
4369 rajveer 15563 
      elif fid == 5:
15564 
        if ftype == TType.BOOL:
15565 
          self.isReminder = iprot.readBool();
15566 
        else:
15567 
          iprot.skip(ftype)
4303 rajveer 15568 
      else:
15569 
        iprot.skip(ftype)
15570 
      iprot.readFieldEnd()
15571 
    iprot.readStructEnd()
15572 
 
15573 
  def write(self, oprot):
15574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15576 
      return
15577 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
15578 
    if self.vendorId is not None:
15579 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15580 
      oprot.writeI64(self.vendorId)
15581 
      oprot.writeFieldEnd()
15582 
    if self.itemId is not None:
15583 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15584 
      oprot.writeI64(self.itemId)
15585 
      oprot.writeFieldEnd()
15586 
    if self.quantity is not None:
15587 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15588 
      oprot.writeI64(self.quantity)
15589 
      oprot.writeFieldEnd()
15590 
    if self.estimate is not None:
15591 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15592 
      oprot.writeI64(self.estimate)
15593 
      oprot.writeFieldEnd()
4369 rajveer 15594 
    if self.isReminder is not None:
15595 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15596 
      oprot.writeBool(self.isReminder)
15597 
      oprot.writeFieldEnd()
4303 rajveer 15598 
    oprot.writeFieldStop()
15599 
    oprot.writeStructEnd()
15600 
 
15601 
  def validate(self):
15602 
    return
15603 
 
15604 
 
15605 
  def __repr__(self):
15606 
    L = ['%s=%r' % (key, value)
15607 
      for key, value in self.__dict__.iteritems()]
15608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15609 
 
15610 
  def __eq__(self, other):
15611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15612 
 
15613 
  def __ne__(self, other):
15614 
    return not (self == other)
15615 
 
15616 
class markOrdersAsPORaised_result:
15617 
  """
15618 
  Attributes:
15619 
   - ex
15620 
  """
15621 
 
15622 
  thrift_spec = (
15623 
    None, # 0
15624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15625 
  )
15626 
 
15627 
  def __init__(self, ex=None,):
15628 
    self.ex = ex
15629 
 
15630 
  def read(self, iprot):
15631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15633 
      return
15634 
    iprot.readStructBegin()
15635 
    while True:
15636 
      (fname, ftype, fid) = iprot.readFieldBegin()
15637 
      if ftype == TType.STOP:
15638 
        break
15639 
      if fid == 1:
15640 
        if ftype == TType.STRUCT:
15641 
          self.ex = TransactionServiceException()
15642 
          self.ex.read(iprot)
15643 
        else:
15644 
          iprot.skip(ftype)
15645 
      else:
15646 
        iprot.skip(ftype)
15647 
      iprot.readFieldEnd()
15648 
    iprot.readStructEnd()
15649 
 
15650 
  def write(self, oprot):
15651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15653 
      return
15654 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
15655 
    if self.ex is not None:
15656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15657 
      self.ex.write(oprot)
15658 
      oprot.writeFieldEnd()
15659 
    oprot.writeFieldStop()
15660 
    oprot.writeStructEnd()
15661 
 
15662 
  def validate(self):
15663 
    return
15664 
 
15665 
 
15666 
  def __repr__(self):
15667 
    L = ['%s=%r' % (key, value)
15668 
      for key, value in self.__dict__.iteritems()]
15669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15670 
 
15671 
  def __eq__(self, other):
15672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15673 
 
15674 
  def __ne__(self, other):
15675 
    return not (self == other)
15676 
 
15677 
class markOrdersAsReversalInitiated_args:
15678 
  """
15679 
  Attributes:
15680 
   - vendorId
15681 
   - itemId
15682 
   - quantity
15683 
   - estimate
4369 rajveer 15684 
   - isReminder
4303 rajveer 15685 
  """
15686 
 
15687 
  thrift_spec = (
15688 
    None, # 0
15689 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15690 
    (2, TType.I64, 'itemId', None, None, ), # 2
15691 
    (3, TType.I64, 'quantity', None, None, ), # 3
15692 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15693 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15694 
  )
15695 
 
4369 rajveer 15696 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15697 
    self.vendorId = vendorId
15698 
    self.itemId = itemId
15699 
    self.quantity = quantity
15700 
    self.estimate = estimate
4369 rajveer 15701 
    self.isReminder = isReminder
4303 rajveer 15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 1:
15713 
        if ftype == TType.I64:
15714 
          self.vendorId = iprot.readI64();
15715 
        else:
15716 
          iprot.skip(ftype)
15717 
      elif fid == 2:
15718 
        if ftype == TType.I64:
15719 
          self.itemId = iprot.readI64();
15720 
        else:
15721 
          iprot.skip(ftype)
15722 
      elif fid == 3:
15723 
        if ftype == TType.I64:
15724 
          self.quantity = iprot.readI64();
15725 
        else:
15726 
          iprot.skip(ftype)
15727 
      elif fid == 4:
15728 
        if ftype == TType.I64:
15729 
          self.estimate = iprot.readI64();
15730 
        else:
15731 
          iprot.skip(ftype)
4369 rajveer 15732 
      elif fid == 5:
15733 
        if ftype == TType.BOOL:
15734 
          self.isReminder = iprot.readBool();
15735 
        else:
15736 
          iprot.skip(ftype)
4303 rajveer 15737 
      else:
15738 
        iprot.skip(ftype)
15739 
      iprot.readFieldEnd()
15740 
    iprot.readStructEnd()
15741 
 
15742 
  def write(self, oprot):
15743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15745 
      return
15746 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
15747 
    if self.vendorId is not None:
15748 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15749 
      oprot.writeI64(self.vendorId)
15750 
      oprot.writeFieldEnd()
15751 
    if self.itemId is not None:
15752 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15753 
      oprot.writeI64(self.itemId)
15754 
      oprot.writeFieldEnd()
15755 
    if self.quantity is not None:
15756 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15757 
      oprot.writeI64(self.quantity)
15758 
      oprot.writeFieldEnd()
15759 
    if self.estimate is not None:
15760 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15761 
      oprot.writeI64(self.estimate)
15762 
      oprot.writeFieldEnd()
4369 rajveer 15763 
    if self.isReminder is not None:
15764 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15765 
      oprot.writeBool(self.isReminder)
15766 
      oprot.writeFieldEnd()
4303 rajveer 15767 
    oprot.writeFieldStop()
15768 
    oprot.writeStructEnd()
15769 
 
15770 
  def validate(self):
15771 
    return
15772 
 
15773 
 
15774 
  def __repr__(self):
15775 
    L = ['%s=%r' % (key, value)
15776 
      for key, value in self.__dict__.iteritems()]
15777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15778 
 
15779 
  def __eq__(self, other):
15780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15781 
 
15782 
  def __ne__(self, other):
15783 
    return not (self == other)
15784 
 
15785 
class markOrdersAsReversalInitiated_result:
15786 
  """
15787 
  Attributes:
15788 
   - ex
15789 
  """
15790 
 
15791 
  thrift_spec = (
15792 
    None, # 0
15793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15794 
  )
15795 
 
15796 
  def __init__(self, ex=None,):
15797 
    self.ex = ex
15798 
 
15799 
  def read(self, iprot):
15800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15802 
      return
15803 
    iprot.readStructBegin()
15804 
    while True:
15805 
      (fname, ftype, fid) = iprot.readFieldBegin()
15806 
      if ftype == TType.STOP:
15807 
        break
15808 
      if fid == 1:
15809 
        if ftype == TType.STRUCT:
15810 
          self.ex = TransactionServiceException()
15811 
          self.ex.read(iprot)
15812 
        else:
15813 
          iprot.skip(ftype)
15814 
      else:
15815 
        iprot.skip(ftype)
15816 
      iprot.readFieldEnd()
15817 
    iprot.readStructEnd()
15818 
 
15819 
  def write(self, oprot):
15820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15822 
      return
15823 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
15824 
    if self.ex is not None:
15825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15826 
      self.ex.write(oprot)
15827 
      oprot.writeFieldEnd()
15828 
    oprot.writeFieldStop()
15829 
    oprot.writeStructEnd()
15830 
 
15831 
  def validate(self):
15832 
    return
15833 
 
15834 
 
15835 
  def __repr__(self):
15836 
    L = ['%s=%r' % (key, value)
15837 
      for key, value in self.__dict__.iteritems()]
15838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15839 
 
15840 
  def __eq__(self, other):
15841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15842 
 
15843 
  def __ne__(self, other):
15844 
    return not (self == other)
15845 
 
15846 
class markOrdersAsNotAvailabke_args:
15847 
  """
15848 
  Attributes:
15849 
   - vendorId
15850 
   - itemId
15851 
   - quantity
15852 
   - estimate
4369 rajveer 15853 
   - isReminder
4303 rajveer 15854 
  """
15855 
 
15856 
  thrift_spec = (
15857 
    None, # 0
15858 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15859 
    (2, TType.I64, 'itemId', None, None, ), # 2
15860 
    (3, TType.I64, 'quantity', None, None, ), # 3
15861 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15862 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15863 
  )
15864 
 
4369 rajveer 15865 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15866 
    self.vendorId = vendorId
15867 
    self.itemId = itemId
15868 
    self.quantity = quantity
15869 
    self.estimate = estimate
4369 rajveer 15870 
    self.isReminder = isReminder
4303 rajveer 15871 
 
15872 
  def read(self, iprot):
15873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15875 
      return
15876 
    iprot.readStructBegin()
15877 
    while True:
15878 
      (fname, ftype, fid) = iprot.readFieldBegin()
15879 
      if ftype == TType.STOP:
15880 
        break
15881 
      if fid == 1:
15882 
        if ftype == TType.I64:
15883 
          self.vendorId = iprot.readI64();
15884 
        else:
15885 
          iprot.skip(ftype)
15886 
      elif fid == 2:
15887 
        if ftype == TType.I64:
15888 
          self.itemId = iprot.readI64();
15889 
        else:
15890 
          iprot.skip(ftype)
15891 
      elif fid == 3:
15892 
        if ftype == TType.I64:
15893 
          self.quantity = iprot.readI64();
15894 
        else:
15895 
          iprot.skip(ftype)
15896 
      elif fid == 4:
15897 
        if ftype == TType.I64:
15898 
          self.estimate = iprot.readI64();
15899 
        else:
15900 
          iprot.skip(ftype)
4369 rajveer 15901 
      elif fid == 5:
15902 
        if ftype == TType.BOOL:
15903 
          self.isReminder = iprot.readBool();
15904 
        else:
15905 
          iprot.skip(ftype)
4303 rajveer 15906 
      else:
15907 
        iprot.skip(ftype)
15908 
      iprot.readFieldEnd()
15909 
    iprot.readStructEnd()
15910 
 
15911 
  def write(self, oprot):
15912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15914 
      return
15915 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15916 
    if self.vendorId is not None:
15917 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15918 
      oprot.writeI64(self.vendorId)
15919 
      oprot.writeFieldEnd()
15920 
    if self.itemId is not None:
15921 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15922 
      oprot.writeI64(self.itemId)
15923 
      oprot.writeFieldEnd()
15924 
    if self.quantity is not None:
15925 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15926 
      oprot.writeI64(self.quantity)
15927 
      oprot.writeFieldEnd()
15928 
    if self.estimate is not None:
15929 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15930 
      oprot.writeI64(self.estimate)
15931 
      oprot.writeFieldEnd()
4369 rajveer 15932 
    if self.isReminder is not None:
15933 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15934 
      oprot.writeBool(self.isReminder)
15935 
      oprot.writeFieldEnd()
4303 rajveer 15936 
    oprot.writeFieldStop()
15937 
    oprot.writeStructEnd()
15938 
 
15939 
  def validate(self):
15940 
    return
15941 
 
15942 
 
15943 
  def __repr__(self):
15944 
    L = ['%s=%r' % (key, value)
15945 
      for key, value in self.__dict__.iteritems()]
15946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15947 
 
15948 
  def __eq__(self, other):
15949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15950 
 
15951 
  def __ne__(self, other):
15952 
    return not (self == other)
15953 
 
15954 
class markOrdersAsNotAvailabke_result:
15955 
  """
15956 
  Attributes:
15957 
   - ex
15958 
  """
15959 
 
15960 
  thrift_spec = (
15961 
    None, # 0
15962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15963 
  )
15964 
 
15965 
  def __init__(self, ex=None,):
15966 
    self.ex = ex
15967 
 
15968 
  def read(self, iprot):
15969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15971 
      return
15972 
    iprot.readStructBegin()
15973 
    while True:
15974 
      (fname, ftype, fid) = iprot.readFieldBegin()
15975 
      if ftype == TType.STOP:
15976 
        break
15977 
      if fid == 1:
15978 
        if ftype == TType.STRUCT:
15979 
          self.ex = TransactionServiceException()
15980 
          self.ex.read(iprot)
15981 
        else:
15982 
          iprot.skip(ftype)
15983 
      else:
15984 
        iprot.skip(ftype)
15985 
      iprot.readFieldEnd()
15986 
    iprot.readStructEnd()
15987 
 
15988 
  def write(self, oprot):
15989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15991 
      return
15992 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
15993 
    if self.ex is not None:
15994 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15995 
      self.ex.write(oprot)
15996 
      oprot.writeFieldEnd()
15997 
    oprot.writeFieldStop()
15998 
    oprot.writeStructEnd()
15999 
 
16000 
  def validate(self):
16001 
    return
16002 
 
16003 
 
16004 
  def __repr__(self):
16005 
    L = ['%s=%r' % (key, value)
16006 
      for key, value in self.__dict__.iteritems()]
16007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16008 
 
16009 
  def __eq__(self, other):
16010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16011 
 
16012 
  def __ne__(self, other):
16013 
    return not (self == other)
4369 rajveer 16014 
 
16015 
class markOrdersAsTimeout_args:
16016 
  """
16017 
  Attributes:
16018 
   - vendorId
16019 
  """
16020 
 
16021 
  thrift_spec = (
16022 
    None, # 0
16023 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16024 
  )
16025 
 
16026 
  def __init__(self, vendorId=None,):
16027 
    self.vendorId = vendorId
16028 
 
16029 
  def read(self, iprot):
16030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16032 
      return
16033 
    iprot.readStructBegin()
16034 
    while True:
16035 
      (fname, ftype, fid) = iprot.readFieldBegin()
16036 
      if ftype == TType.STOP:
16037 
        break
16038 
      if fid == 1:
16039 
        if ftype == TType.I64:
16040 
          self.vendorId = iprot.readI64();
16041 
        else:
16042 
          iprot.skip(ftype)
16043 
      else:
16044 
        iprot.skip(ftype)
16045 
      iprot.readFieldEnd()
16046 
    iprot.readStructEnd()
16047 
 
16048 
  def write(self, oprot):
16049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16051 
      return
16052 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16053 
    if self.vendorId is not None:
16054 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16055 
      oprot.writeI64(self.vendorId)
16056 
      oprot.writeFieldEnd()
16057 
    oprot.writeFieldStop()
16058 
    oprot.writeStructEnd()
16059 
 
16060 
  def validate(self):
16061 
    return
16062 
 
16063 
 
16064 
  def __repr__(self):
16065 
    L = ['%s=%r' % (key, value)
16066 
      for key, value in self.__dict__.iteritems()]
16067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16068 
 
16069 
  def __eq__(self, other):
16070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16071 
 
16072 
  def __ne__(self, other):
16073 
    return not (self == other)
16074 
 
16075 
class markOrdersAsTimeout_result:
16076 
  """
16077 
  Attributes:
16078 
   - success
16079 
   - ex
16080 
  """
16081 
 
16082 
  thrift_spec = (
16083 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16085 
  )
16086 
 
16087 
  def __init__(self, success=None, ex=None,):
16088 
    self.success = success
16089 
    self.ex = ex
16090 
 
16091 
  def read(self, iprot):
16092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16094 
      return
16095 
    iprot.readStructBegin()
16096 
    while True:
16097 
      (fname, ftype, fid) = iprot.readFieldBegin()
16098 
      if ftype == TType.STOP:
16099 
        break
16100 
      if fid == 0:
16101 
        if ftype == TType.MAP:
16102 
          self.success = {}
16103 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
16104 
          for _i265 in xrange(_size261):
16105 
            _key266 = iprot.readI32();
16106 
            _val267 = TimeoutSummary()
16107 
            _val267.read(iprot)
16108 
            self.success[_key266] = _val267
16109 
          iprot.readMapEnd()
16110 
        else:
16111 
          iprot.skip(ftype)
16112 
      elif fid == 1:
16113 
        if ftype == TType.STRUCT:
16114 
          self.ex = TransactionServiceException()
16115 
          self.ex.read(iprot)
16116 
        else:
16117 
          iprot.skip(ftype)
16118 
      else:
16119 
        iprot.skip(ftype)
16120 
      iprot.readFieldEnd()
16121 
    iprot.readStructEnd()
16122 
 
16123 
  def write(self, oprot):
16124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16126 
      return
16127 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16128 
    if self.success is not None:
16129 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16130 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
16131 
      for kiter268,viter269 in self.success.items():
16132 
        oprot.writeI32(kiter268)
16133 
        viter269.write(oprot)
16134 
      oprot.writeMapEnd()
16135 
      oprot.writeFieldEnd()
16136 
    if self.ex is not None:
16137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16138 
      self.ex.write(oprot)
16139 
      oprot.writeFieldEnd()
16140 
    oprot.writeFieldStop()
16141 
    oprot.writeStructEnd()
16142 
 
16143 
  def validate(self):
16144 
    return
16145 
 
16146 
 
16147 
  def __repr__(self):
16148 
    L = ['%s=%r' % (key, value)
16149 
      for key, value in self.__dict__.iteritems()]
16150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16151 
 
16152 
  def __eq__(self, other):
16153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16154 
 
16155 
  def __ne__(self, other):
16156 
    return not (self == other)
4386 anupam.sin 16157 
 
16158 
class getOrderForAwb_args:
16159 
  """
16160 
  Attributes:
16161 
   - awb
16162 
  """
16163 
 
16164 
  thrift_spec = (
16165 
    None, # 0
16166 
    (1, TType.STRING, 'awb', None, None, ), # 1
16167 
  )
16168 
 
16169 
  def __init__(self, awb=None,):
16170 
    self.awb = awb
16171 
 
16172 
  def read(self, iprot):
16173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16175 
      return
16176 
    iprot.readStructBegin()
16177 
    while True:
16178 
      (fname, ftype, fid) = iprot.readFieldBegin()
16179 
      if ftype == TType.STOP:
16180 
        break
16181 
      if fid == 1:
16182 
        if ftype == TType.STRING:
16183 
          self.awb = iprot.readString();
16184 
        else:
16185 
          iprot.skip(ftype)
16186 
      else:
16187 
        iprot.skip(ftype)
16188 
      iprot.readFieldEnd()
16189 
    iprot.readStructEnd()
16190 
 
16191 
  def write(self, oprot):
16192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16194 
      return
16195 
    oprot.writeStructBegin('getOrderForAwb_args')
16196 
    if self.awb is not None:
16197 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16198 
      oprot.writeString(self.awb)
16199 
      oprot.writeFieldEnd()
16200 
    oprot.writeFieldStop()
16201 
    oprot.writeStructEnd()
16202 
 
16203 
  def validate(self):
16204 
    return
16205 
 
16206 
 
16207 
  def __repr__(self):
16208 
    L = ['%s=%r' % (key, value)
16209 
      for key, value in self.__dict__.iteritems()]
16210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16211 
 
16212 
  def __eq__(self, other):
16213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16214 
 
16215 
  def __ne__(self, other):
16216 
    return not (self == other)
16217 
 
16218 
class getOrderForAwb_result:
16219 
  """
16220 
  Attributes:
16221 
   - success
16222 
   - ex
16223 
  """
16224 
 
16225 
  thrift_spec = (
16226 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16228 
  )
16229 
 
16230 
  def __init__(self, success=None, ex=None,):
16231 
    self.success = success
16232 
    self.ex = ex
16233 
 
16234 
  def read(self, iprot):
16235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16237 
      return
16238 
    iprot.readStructBegin()
16239 
    while True:
16240 
      (fname, ftype, fid) = iprot.readFieldBegin()
16241 
      if ftype == TType.STOP:
16242 
        break
16243 
      if fid == 0:
16244 
        if ftype == TType.STRUCT:
16245 
          self.success = Order()
16246 
          self.success.read(iprot)
16247 
        else:
16248 
          iprot.skip(ftype)
16249 
      elif fid == 1:
16250 
        if ftype == TType.STRUCT:
16251 
          self.ex = TransactionServiceException()
16252 
          self.ex.read(iprot)
16253 
        else:
16254 
          iprot.skip(ftype)
16255 
      else:
16256 
        iprot.skip(ftype)
16257 
      iprot.readFieldEnd()
16258 
    iprot.readStructEnd()
16259 
 
16260 
  def write(self, oprot):
16261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16263 
      return
16264 
    oprot.writeStructBegin('getOrderForAwb_result')
16265 
    if self.success is not None:
16266 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16267 
      self.success.write(oprot)
16268 
      oprot.writeFieldEnd()
16269 
    if self.ex is not None:
16270 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16271 
      self.ex.write(oprot)
16272 
      oprot.writeFieldEnd()
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
4506 phani.kuma 16290 
 
16291 
class getOrdersForProviderForStatus_args:
16292 
  """
16293 
  Attributes:
16294 
   - logistics_provider_id
16295 
   - order_status
16296 
  """
16297 
 
16298 
  thrift_spec = (
16299 
    None, # 0
16300 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16301 
    (2, TType.I32, 'order_status', None, None, ), # 2
16302 
  )
16303 
 
16304 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16305 
    self.logistics_provider_id = logistics_provider_id
16306 
    self.order_status = order_status
16307 
 
16308 
  def read(self, iprot):
16309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16311 
      return
16312 
    iprot.readStructBegin()
16313 
    while True:
16314 
      (fname, ftype, fid) = iprot.readFieldBegin()
16315 
      if ftype == TType.STOP:
16316 
        break
16317 
      if fid == 1:
16318 
        if ftype == TType.I64:
16319 
          self.logistics_provider_id = iprot.readI64();
16320 
        else:
16321 
          iprot.skip(ftype)
16322 
      elif fid == 2:
16323 
        if ftype == TType.I32:
16324 
          self.order_status = iprot.readI32();
16325 
        else:
16326 
          iprot.skip(ftype)
16327 
      else:
16328 
        iprot.skip(ftype)
16329 
      iprot.readFieldEnd()
16330 
    iprot.readStructEnd()
16331 
 
16332 
  def write(self, oprot):
16333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16335 
      return
16336 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16337 
    if self.logistics_provider_id is not None:
16338 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16339 
      oprot.writeI64(self.logistics_provider_id)
16340 
      oprot.writeFieldEnd()
16341 
    if self.order_status is not None:
16342 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16343 
      oprot.writeI32(self.order_status)
16344 
      oprot.writeFieldEnd()
16345 
    oprot.writeFieldStop()
16346 
    oprot.writeStructEnd()
16347 
 
16348 
  def validate(self):
16349 
    return
16350 
 
16351 
 
16352 
  def __repr__(self):
16353 
    L = ['%s=%r' % (key, value)
16354 
      for key, value in self.__dict__.iteritems()]
16355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16356 
 
16357 
  def __eq__(self, other):
16358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16359 
 
16360 
  def __ne__(self, other):
16361 
    return not (self == other)
16362 
 
16363 
class getOrdersForProviderForStatus_result:
16364 
  """
16365 
  Attributes:
16366 
   - success
16367 
   - ex
16368 
  """
16369 
 
16370 
  thrift_spec = (
16371 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16373 
  )
16374 
 
16375 
  def __init__(self, success=None, ex=None,):
16376 
    self.success = success
16377 
    self.ex = ex
16378 
 
16379 
  def read(self, iprot):
16380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16382 
      return
16383 
    iprot.readStructBegin()
16384 
    while True:
16385 
      (fname, ftype, fid) = iprot.readFieldBegin()
16386 
      if ftype == TType.STOP:
16387 
        break
16388 
      if fid == 0:
16389 
        if ftype == TType.LIST:
16390 
          self.success = []
16391 
          (_etype273, _size270) = iprot.readListBegin()
16392 
          for _i274 in xrange(_size270):
16393 
            _elem275 = Order()
16394 
            _elem275.read(iprot)
16395 
            self.success.append(_elem275)
16396 
          iprot.readListEnd()
16397 
        else:
16398 
          iprot.skip(ftype)
16399 
      elif fid == 1:
16400 
        if ftype == TType.STRUCT:
16401 
          self.ex = TransactionServiceException()
16402 
          self.ex.read(iprot)
16403 
        else:
16404 
          iprot.skip(ftype)
16405 
      else:
16406 
        iprot.skip(ftype)
16407 
      iprot.readFieldEnd()
16408 
    iprot.readStructEnd()
16409 
 
16410 
  def write(self, oprot):
16411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16413 
      return
16414 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16415 
    if self.success is not None:
16416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16417 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16418 
      for iter276 in self.success:
16419 
        iter276.write(oprot)
16420 
      oprot.writeListEnd()
16421 
      oprot.writeFieldEnd()
16422 
    if self.ex is not None:
16423 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16424 
      self.ex.write(oprot)
16425 
      oprot.writeFieldEnd()
16426 
    oprot.writeFieldStop()
16427 
    oprot.writeStructEnd()
16428 
 
16429 
  def validate(self):
16430 
    return
16431 
 
16432 
 
16433 
  def __repr__(self):
16434 
    L = ['%s=%r' % (key, value)
16435 
      for key, value in self.__dict__.iteritems()]
16436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16437 
 
16438 
  def __eq__(self, other):
16439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16440 
 
16441 
  def __ne__(self, other):
16442 
    return not (self == other)