Subversion Repositories SmartDukaan

Rev

Rev 4715 | Rev 4757 | 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 
 
4658 mandeep.dh 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 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
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 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.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    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.
435 
    Returns the final flag status.
436 
    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 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
4712 rajveer 443 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
444 
    """
445 
    Parameters:
446 
     - orderId
447 
     - deliveryTimestamp
448 
     - receiver
449 
    """
450 
    pass
451 
 
4454 rajveer 452 
  def markOrderDoaRequestReceived(self, orderId):
453 
    """
454 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
455 
 
456 
    Parameters:
457 
     - orderId
458 
    """
459 
    pass
460 
 
461 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
462 
    """
463 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
464 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
465 
 
466 
    Parameters:
467 
     - orderId
468 
     - isAuthorized
469 
    """
470 
    pass
471 
 
4488 rajveer 472 
  def markOrderReturnRequestReceived(self, orderId):
473 
    """
474 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
475 
 
476 
    Parameters:
477 
     - orderId
478 
    """
479 
    pass
480 
 
481 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
482 
    """
483 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
484 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
485 
 
486 
    Parameters:
487 
     - orderId
488 
     - isAuthorized
489 
    """
490 
    pass
491 
 
4579 rajveer 492 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 493 
    """
494 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 495 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
496 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 497 
    For any other status, it returns false.
498 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 499 
 
2536 chandransh 500 
    Parameters:
501 
     - orderId
4579 rajveer 502 
     - providerId
2536 chandransh 503 
    """
504 
    pass
505 
 
4602 rajveer 506 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 507 
    """
4452 rajveer 508 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 509 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
510 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
511 
    	3. Returns true
2591 chandransh 512 
    If the order is in any other status, it returns false.
2536 chandransh 513 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 514 
 
2536 chandransh 515 
    Parameters:
516 
     - orderId
517 
     - pickupNumber
4602 rajveer 518 
     - providerId
2536 chandransh 519 
    """
520 
    pass
521 
 
2764 chandransh 522 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
523 
    """
524 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
525 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 526 
 
2764 chandransh 527 
    Parameters:
528 
     - providerId
529 
     - pickupDetails
530 
    """
531 
    pass
532 
 
4741 phani.kuma 533 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
534 
    """
535 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
536 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
537 
 
538 
    Parameters:
539 
     - providerId
540 
     - pickupDetails
541 
    """
542 
    pass
543 
 
4479 rajveer 544 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 545 
    """
4452 rajveer 546 
    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 547 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 548 
    If the order is in any other state, it returns false.
549 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 550 
 
2591 chandransh 551 
    Parameters:
552 
     - orderId
4479 rajveer 553 
     - receiveCondition
2591 chandransh 554 
    """
555 
    pass
2536 chandransh 556 
 
2591 chandransh 557 
  def validateDoa(self, orderId, isValid):
558 
    """
4452 rajveer 559 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 560 
    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 561 
    If the order is in any other state, it returns false.
562 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 563 
 
2591 chandransh 564 
    Parameters:
565 
     - orderId
566 
     - isValid
567 
    """
568 
    pass
569 
 
4495 rajveer 570 
  def validateReturnProduct(self, orderId, isUsable):
571 
    """
572 
    Parameters:
573 
     - orderId
574 
     - isUsable
575 
    """
576 
    pass
577 
 
2616 chandransh 578 
  def reshipOrder(self, orderId):
579 
    """
4484 rajveer 580 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 581 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 582 
    	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 583 
 
584 
    If the order is in DOA_CERT_VALID state, it does the following:
585 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
586 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 587 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 588 
 
2616 chandransh 589 
    Returns the id of the newly created order.
3431 rajveer 590 
 
2616 chandransh 591 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 592 
 
2616 chandransh 593 
    Parameters:
594 
     - orderId
595 
    """
596 
    pass
2591 chandransh 597 
 
3226 chandransh 598 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 599 
    """
4484 rajveer 600 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 601 
    	1. Creates a refund request for batch processing.
602 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 603 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 604 
 
2616 chandransh 605 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
606 
    	1. Creates a refund request for batch processing.
3226 chandransh 607 
    	2. Cancels the reservation of the item in the warehouse.
608 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 609 
 
3226 chandransh 610 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
611 
    	1. Cancels the reservation of the item in the warehouse.
612 
    	2. Marks the current order as CANCELED.
613 
 
614 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
615 
 
2616 chandransh 616 
    Returns True if it is successful, False otherwise.
3431 rajveer 617 
 
2616 chandransh 618 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 619 
 
2616 chandransh 620 
    Parameters:
621 
     - orderId
3226 chandransh 622 
     - refundedBy
623 
     - reason
2616 chandransh 624 
    """
625 
    pass
626 
 
2690 chandransh 627 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
628 
    """
629 
    Get all return orders created between the from and to dates for the given warehouse.
630 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 631 
 
2690 chandransh 632 
    Parameters:
633 
     - warehouseId
634 
     - fromDate
635 
     - toDate
636 
    """
637 
    pass
2616 chandransh 638 
 
2700 chandransh 639 
  def getReturnOrder(self, id):
640 
    """
641 
    Returns the ReturnOrder corresponding to the given id.
642 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 643 
 
2700 chandransh 644 
    Parameters:
645 
     - id
646 
    """
647 
    pass
648 
 
2690 chandransh 649 
  def processReturn(self, returnOrderId):
650 
    """
651 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 652 
 
2690 chandransh 653 
    Parameters:
654 
     - returnOrderId
655 
    """
656 
    pass
657 
 
2819 chandransh 658 
  def createPurchaseOrder(self, warehouseId):
659 
    """
4586 mandeep.dh 660 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
661 
    Returns the list of PO no. of the newly created purchase order.
662 
    Returns null if no new purchase order had to be created.
3431 rajveer 663 
 
2819 chandransh 664 
    Parameters:
665 
     - warehouseId
666 
    """
667 
    pass
2690 chandransh 668 
 
3451 chandransh 669 
  def updateWeight(self, orderId, weight):
670 
    """
671 
    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 672 
 
3451 chandransh 673 
    Parameters:
674 
     - orderId
675 
     - weight
676 
    """
677 
    pass
678 
 
3469 chandransh 679 
  def changeItem(self, orderId, itemId):
680 
    """
681 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
682 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 683 
 
3469 chandransh 684 
    Parameters:
685 
     - orderId
686 
     - itemId
687 
    """
688 
    pass
689 
 
690 
  def shiftToWarehouse(self, orderId, warehouseId):
691 
    """
692 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
693 
 
694 
    Parameters:
695 
     - orderId
696 
     - warehouseId
697 
    """
698 
    pass
699 
 
4647 rajveer 700 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 701 
    """
702 
    Adds the given delay reason to the given order.
3986 chandransh 703 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 704 
    Raises an exception if no order with the given id can be found.
3469 chandransh 705 
 
3553 chandransh 706 
    Parameters:
707 
     - orderId
708 
     - delayReason
3986 chandransh 709 
     - furtherDelay
4647 rajveer 710 
     - delayReasonText
3553 chandransh 711 
    """
712 
    pass
713 
 
3956 chandransh 714 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
715 
    """
716 
    Marks the COD orders with given AWB nos. as having been processed.
717 
    Updates the captured amount for the corresponding payment.
3553 chandransh 718 
 
3956 chandransh 719 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
720 
    1. There is no order corresponding to an AWB number.
721 
    2. The captured amount for a payment exceeds the total payment.
722 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
723 
 
724 
    Parameters:
725 
     - collectedAmountMap
726 
     - xferBy
727 
     - xferTxnId
728 
     - xferDate
729 
    """
730 
    pass
731 
 
4008 mandeep.dh 732 
  def getTransactionsRequiringExtraProcessing(self, category):
733 
    """
4065 mandeep.dh 734 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 735 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 736 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 737 
 
4008 mandeep.dh 738 
    Parameters:
739 
     - category
740 
    """
741 
    pass
742 
 
743 
  def markTransactionAsProcessed(self, transactionId, category):
744 
    """
745 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 746 
    It essentially deletes the transaction id record for a particular
747 
    processing type category (if present) from DB.
748 
    This is currently used by CRM application.
4008 mandeep.dh 749 
 
750 
    Parameters:
751 
     - transactionId
752 
     - category
753 
    """
754 
    pass
755 
 
4018 chandransh 756 
  def getItemWiseRiskyOrdersCount(self, ):
757 
    """
758 
    Returns a map containing the number of risky orders keyed by item id. A risky order
759 
    is defined as one whose shipping date is about to expire.
760 
    """
761 
    pass
4008 mandeep.dh 762 
 
4295 varun.gupt 763 
  def getOrdersForItemIds(self, itemIds):
764 
    """
765 
    Returns a list of all orders which have items with given id
766 
 
767 
    Parameters:
768 
     - itemIds
769 
    """
770 
    pass
771 
 
4247 rajveer 772 
  def markOrderCancellationRequestReceived(self, orderId):
773 
    """
774 
    Mark order as cancellation request received. If customer sends request of cancellation of
775 
    a particular order, this method will be called. It will just change status of the order
776 
    depending on its current status. It also records the previous status, so that we can move
777 
    back to that status if cancellation request is denied.
4018 chandransh 778 
 
4247 rajveer 779 
    Parameters:
780 
     - orderId
781 
    """
782 
    pass
783 
 
784 
  def markOrderCancellationRequestConfirmed(self, orderId):
785 
    """
786 
    If we decide to to cancel order, CRM will call this method to move the status of order to
787 
    cancellation request confirmed. After this OM will be able to cancel the order.
788 
 
789 
    Parameters:
790 
     - orderId
791 
    """
792 
    pass
793 
 
794 
  def markOrderCancellationRequestDenied(self, orderId):
795 
    """
796 
    If we decide to not to cancel order, we will move the order ro previous status.
797 
 
798 
    Parameters:
799 
     - orderId
800 
    """
801 
    pass
802 
 
4258 rajveer 803 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 804 
    """
4258 rajveer 805 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
806 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 807 
 
808 
    Parameters:
4258 rajveer 809 
     - transactionId
4247 rajveer 810 
    """
811 
    pass
812 
 
4259 anupam.sin 813 
  def refundTransaction(self, transactionId, refundedBy, reason):
814 
    """
815 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
816 
    need to be cancelled
4247 rajveer 817 
 
4259 anupam.sin 818 
    Parameters:
819 
     - transactionId
820 
     - refundedBy
821 
     - reason
822 
    """
823 
    pass
824 
 
4324 mandeep.dh 825 
  def updateShipmentAddress(self, orderId, addressId):
826 
    """
827 
    Updates shipment address of an order. Delivery and shipping date estimates
828 
    etc. are also updated here.
829 
 
830 
    Throws TransactionServiceException in case address change is not
831 
    possible due to certain reasons such as new pincode in address is
832 
    not serviceable etc.
833 
 
834 
    Parameters:
835 
     - orderId
836 
     - addressId
837 
    """
838 
    pass
839 
 
4285 rajveer 840 
  def acceptOrdersForItemId(self, itemId, inventory):
841 
    """
842 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
843 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 844 
 
4285 rajveer 845 
    Parameters:
846 
     - itemId
847 
     - inventory
848 
    """
849 
    pass
850 
 
4369 rajveer 851 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
4285 rajveer 861 
 
4369 rajveer 862 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 863 
    """
864 
    Parameters:
865 
     - vendorId
866 
     - itemId
867 
     - quantity
868 
     - estimate
4369 rajveer 869 
     - isReminder
4303 rajveer 870 
    """
871 
    pass
872 
 
4369 rajveer 873 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 874 
    """
875 
    Parameters:
876 
     - vendorId
877 
     - itemId
878 
     - quantity
879 
     - estimate
4369 rajveer 880 
     - isReminder
4303 rajveer 881 
    """
882 
    pass
883 
 
4369 rajveer 884 
  def markOrdersAsTimeout(self, vendorId):
885 
    """
886 
    Parameters:
887 
     - vendorId
888 
    """
889 
    pass
4303 rajveer 890 
 
4662 rajveer 891 
  def markOrderAsLostInTransit(self, orderId):
892 
    """
893 
    Mark order as LOST_IN_TRANSIT
894 
 
895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
4386 anupam.sin 900 
  def getOrderForAwb(self, awb):
901 
    """
902 
    Returns the order corresponding to an AWB number
4369 rajveer 903 
 
4386 anupam.sin 904 
    Parameters:
905 
     - awb
906 
    """
907 
    pass
908 
 
4506 phani.kuma 909 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
910 
    """
911 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 912 
 
4506 phani.kuma 913 
    Parameters:
914 
     - logistics_provider_id
915 
     - order_status
916 
    """
917 
    pass
918 
 
4600 varun.gupt 919 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
920 
    """
921 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 922 
 
4600 varun.gupt 923 
    Parameters:
924 
     - vendorId
925 
     - billingDateFrom
926 
     - billingDateTo
927 
    """
928 
    pass
929 
 
4607 rajveer 930 
  def getSlippedSippingDateOrders(self, ):
931 
    pass
932 
 
4709 rajveer 933 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
934 
    """
935 
    Parameters:
936 
     - cancelDateFrom
937 
     - cancelDateTo
938 
    """
939 
    pass
940 
 
4600 varun.gupt 941 
  def saveBluedartSettlements(self, mapAWBAndAmount):
942 
    """
943 
    Parameters:
944 
     - mapAWBAndAmount
945 
    """
946 
    pass
947 
 
948 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
949 
    """
950 
    Parameters:
951 
     - settlementDate
952 
     - paymentGatewayId
953 
     - paymentId
954 
     - serviceTax
955 
     - otherCharges
956 
     - netCollection
957 
    """
958 
    pass
959 
 
960 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
961 
    """
962 
    Parameters:
963 
     - settlementId
964 
     - settlementDate
965 
     - transactionDateFrom
966 
     - transactionDateTo
967 
     - amount
968 
    """
969 
    pass
970 
 
971 
  def getSettlementForPaymentId(self, paymentId):
972 
    """
973 
    Parameters:
974 
     - paymentId
975 
    """
976 
    pass
977 
 
978 
  def getEBSSettlementSummaries(self, ):
979 
    pass
980 
 
981 
  def markEBSSettlementUploaded(self, settlementId):
982 
    """
983 
    Parameters:
984 
     - settlementId
985 
    """
986 
    pass
987 
 
988 
  def getEBSSettlementDate(self, settlementId):
989 
    """
990 
    Parameters:
991 
     - settlementId
992 
    """
993 
    pass
994 
 
4715 varun.gupt 995 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
996 
    """
997 
    Parameters:
998 
     - settlementDateFrom
999 
     - settlementDateTo
1000 
     - isRefund
1001 
    """
1002 
    pass
4600 varun.gupt 1003 
 
4715 varun.gupt 1004 
  def getReshippedOrderIds(self, orderIds):
1005 
    """
1006 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1007 
 
1008 
    Parameters:
1009 
     - orderIds
1010 
    """
1011 
    pass
1012 
 
1013 
 
3376 rajveer 1014 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1015 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1016 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1017 
 
1018 
  def createTransaction(self, transaction):
1019 
    """
1020 
    Parameters:
1021 
     - transaction
1022 
    """
1023 
    self.send_createTransaction(transaction)
132 ashish 1024 
    return self.recv_createTransaction()
94 ashish 1025 
 
1026 
  def send_createTransaction(self, transaction):
1027 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1028 
    args = createTransaction_args()
1029 
    args.transaction = transaction
1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
1034 
  def recv_createTransaction(self, ):
1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
1041 
    result = createTransaction_result()
1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
3431 rajveer 1044 
    if result.success is not None:
132 ashish 1045 
      return result.success
3431 rajveer 1046 
    if result.ex is not None:
94 ashish 1047 
      raise result.ex
132 ashish 1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1049 
 
1050 
  def getTransaction(self, id):
1051 
    """
1052 
    Parameters:
1053 
     - id
1054 
    """
1055 
    self.send_getTransaction(id)
1056 
    return self.recv_getTransaction()
1057 
 
1058 
  def send_getTransaction(self, id):
1059 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1060 
    args = getTransaction_args()
1061 
    args.id = id
1062 
    args.write(self._oprot)
1063 
    self._oprot.writeMessageEnd()
1064 
    self._oprot.trans.flush()
1065 
 
1066 
  def recv_getTransaction(self, ):
1067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1068 
    if mtype == TMessageType.EXCEPTION:
1069 
      x = TApplicationException()
1070 
      x.read(self._iprot)
1071 
      self._iprot.readMessageEnd()
1072 
      raise x
1073 
    result = getTransaction_result()
1074 
    result.read(self._iprot)
1075 
    self._iprot.readMessageEnd()
3431 rajveer 1076 
    if result.success is not None:
94 ashish 1077 
      return result.success
3431 rajveer 1078 
    if result.ex is not None:
94 ashish 1079 
      raise result.ex
1080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1081 
 
1082 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1083 
    """
1084 
    Parameters:
1085 
     - customerId
1086 
     - from_date
1087 
     - to_date
1088 
     - status
1089 
    """
1090 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1091 
    return self.recv_getTransactionsForCustomer()
1092 
 
1093 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1094 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1095 
    args = getTransactionsForCustomer_args()
1096 
    args.customerId = customerId
1097 
    args.from_date = from_date
1098 
    args.to_date = to_date
1099 
    args.status = status
1100 
    args.write(self._oprot)
1101 
    self._oprot.writeMessageEnd()
1102 
    self._oprot.trans.flush()
1103 
 
1104 
  def recv_getTransactionsForCustomer(self, ):
1105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1106 
    if mtype == TMessageType.EXCEPTION:
1107 
      x = TApplicationException()
1108 
      x.read(self._iprot)
1109 
      self._iprot.readMessageEnd()
1110 
      raise x
1111 
    result = getTransactionsForCustomer_result()
1112 
    result.read(self._iprot)
1113 
    self._iprot.readMessageEnd()
3431 rajveer 1114 
    if result.success is not None:
94 ashish 1115 
      return result.success
3431 rajveer 1116 
    if result.ex is not None:
94 ashish 1117 
      raise result.ex
1118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1119 
 
132 ashish 1120 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1121 
    """
1122 
    Parameters:
1123 
     - shoppingCartId
1124 
    """
1125 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1126 
    return self.recv_getTransactionsForShoppingCartId()
1127 
 
1128 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1129 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1130 
    args = getTransactionsForShoppingCartId_args()
1131 
    args.shoppingCartId = shoppingCartId
1132 
    args.write(self._oprot)
1133 
    self._oprot.writeMessageEnd()
1134 
    self._oprot.trans.flush()
1135 
 
1136 
  def recv_getTransactionsForShoppingCartId(self, ):
1137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1138 
    if mtype == TMessageType.EXCEPTION:
1139 
      x = TApplicationException()
1140 
      x.read(self._iprot)
1141 
      self._iprot.readMessageEnd()
1142 
      raise x
1143 
    result = getTransactionsForShoppingCartId_result()
1144 
    result.read(self._iprot)
1145 
    self._iprot.readMessageEnd()
3431 rajveer 1146 
    if result.success is not None:
132 ashish 1147 
      return result.success
3431 rajveer 1148 
    if result.ex is not None:
132 ashish 1149 
      raise result.ex
1150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1151 
 
94 ashish 1152 
  def getTransactionStatus(self, transactionId):
1153 
    """
1154 
    Parameters:
1155 
     - transactionId
1156 
    """
1157 
    self.send_getTransactionStatus(transactionId)
1158 
    return self.recv_getTransactionStatus()
1159 
 
1160 
  def send_getTransactionStatus(self, transactionId):
1161 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1162 
    args = getTransactionStatus_args()
1163 
    args.transactionId = transactionId
1164 
    args.write(self._oprot)
1165 
    self._oprot.writeMessageEnd()
1166 
    self._oprot.trans.flush()
1167 
 
1168 
  def recv_getTransactionStatus(self, ):
1169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1170 
    if mtype == TMessageType.EXCEPTION:
1171 
      x = TApplicationException()
1172 
      x.read(self._iprot)
1173 
      self._iprot.readMessageEnd()
1174 
      raise x
1175 
    result = getTransactionStatus_result()
1176 
    result.read(self._iprot)
1177 
    self._iprot.readMessageEnd()
3431 rajveer 1178 
    if result.success is not None:
94 ashish 1179 
      return result.success
3431 rajveer 1180 
    if result.ex is not None:
94 ashish 1181 
      raise result.ex
1182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1183 
 
1184 
  def changeTransactionStatus(self, transactionId, status, description):
1185 
    """
1186 
    Parameters:
1187 
     - transactionId
1188 
     - status
1189 
     - description
1190 
    """
1191 
    self.send_changeTransactionStatus(transactionId, status, description)
1192 
    return self.recv_changeTransactionStatus()
1193 
 
1194 
  def send_changeTransactionStatus(self, transactionId, status, description):
1195 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1196 
    args = changeTransactionStatus_args()
1197 
    args.transactionId = transactionId
1198 
    args.status = status
1199 
    args.description = description
1200 
    args.write(self._oprot)
1201 
    self._oprot.writeMessageEnd()
1202 
    self._oprot.trans.flush()
1203 
 
1204 
  def recv_changeTransactionStatus(self, ):
1205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1206 
    if mtype == TMessageType.EXCEPTION:
1207 
      x = TApplicationException()
1208 
      x.read(self._iprot)
1209 
      self._iprot.readMessageEnd()
1210 
      raise x
1211 
    result = changeTransactionStatus_result()
1212 
    result.read(self._iprot)
1213 
    self._iprot.readMessageEnd()
3431 rajveer 1214 
    if result.success is not None:
94 ashish 1215 
      return result.success
3431 rajveer 1216 
    if result.ex is not None:
94 ashish 1217 
      raise result.ex
1218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1219 
 
1398 varun.gupt 1220 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1221 
    """
1222 
    Parameters:
1223 
     - transactionId
1224 
    """
1398 varun.gupt 1225 
    self.send_enqueueTransactionInfoEmail(transactionId)
1226 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1227 
 
1398 varun.gupt 1228 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1229 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1230 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1231 
    args.transactionId = transactionId
1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
1398 varun.gupt 1236 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
1398 varun.gupt 1243 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
3431 rajveer 1246 
    if result.success is not None:
1382 varun.gupt 1247 
      return result.success
3431 rajveer 1248 
    if result.ex is not None:
1382 varun.gupt 1249 
      raise result.ex
1398 varun.gupt 1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1251 
 
483 rajveer 1252 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1253 
    """
1254 
    Parameters:
483 rajveer 1255 
     - status
1256 
     - from_date
1257 
     - to_date
1258 
     - warehouse_id
94 ashish 1259 
    """
483 rajveer 1260 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1261 
    return self.recv_getAllOrders()
94 ashish 1262 
 
483 rajveer 1263 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1264 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1265 
    args = getAllOrders_args()
1266 
    args.status = status
1267 
    args.from_date = from_date
1268 
    args.to_date = to_date
1269 
    args.warehouse_id = warehouse_id
94 ashish 1270 
    args.write(self._oprot)
1271 
    self._oprot.writeMessageEnd()
1272 
    self._oprot.trans.flush()
1273 
 
483 rajveer 1274 
  def recv_getAllOrders(self, ):
94 ashish 1275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1276 
    if mtype == TMessageType.EXCEPTION:
1277 
      x = TApplicationException()
1278 
      x.read(self._iprot)
1279 
      self._iprot.readMessageEnd()
1280 
      raise x
483 rajveer 1281 
    result = getAllOrders_result()
94 ashish 1282 
    result.read(self._iprot)
1283 
    self._iprot.readMessageEnd()
3431 rajveer 1284 
    if result.success is not None:
94 ashish 1285 
      return result.success
3431 rajveer 1286 
    if result.ex is not None:
94 ashish 1287 
      raise result.ex
483 rajveer 1288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1289 
 
4133 chandransh 1290 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1291 
    """
1292 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1293 
    Pass the status as null and the limit as 0 to ignore them.
1294 
 
1295 
    Parameters:
1296 
     - statuses
1297 
     - offset
1298 
     - limit
1299 
     - warehouse_id
1300 
    """
1301 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1302 
    return self.recv_getOrdersInBatch()
1303 
 
1304 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1305 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1306 
    args = getOrdersInBatch_args()
1307 
    args.statuses = statuses
1308 
    args.offset = offset
1309 
    args.limit = limit
1310 
    args.warehouse_id = warehouse_id
1311 
    args.write(self._oprot)
1312 
    self._oprot.writeMessageEnd()
1313 
    self._oprot.trans.flush()
1314 
 
1315 
  def recv_getOrdersInBatch(self, ):
1316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1317 
    if mtype == TMessageType.EXCEPTION:
1318 
      x = TApplicationException()
1319 
      x.read(self._iprot)
1320 
      self._iprot.readMessageEnd()
1321 
      raise x
1322 
    result = getOrdersInBatch_result()
1323 
    result.read(self._iprot)
1324 
    self._iprot.readMessageEnd()
1325 
    if result.success is not None:
1326 
      return result.success
1327 
    if result.ex is not None:
1328 
      raise result.ex
1329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1330 
 
1331 
  def getOrderCount(self, statuses, warehouseId):
1332 
    """
1333 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1334 
 
1335 
    Parameters:
1336 
     - statuses
1337 
     - warehouseId
1338 
    """
1339 
    self.send_getOrderCount(statuses, warehouseId)
1340 
    return self.recv_getOrderCount()
1341 
 
1342 
  def send_getOrderCount(self, statuses, warehouseId):
1343 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1344 
    args = getOrderCount_args()
1345 
    args.statuses = statuses
1346 
    args.warehouseId = warehouseId
1347 
    args.write(self._oprot)
1348 
    self._oprot.writeMessageEnd()
1349 
    self._oprot.trans.flush()
1350 
 
1351 
  def recv_getOrderCount(self, ):
1352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1353 
    if mtype == TMessageType.EXCEPTION:
1354 
      x = TApplicationException()
1355 
      x.read(self._iprot)
1356 
      self._iprot.readMessageEnd()
1357 
      raise x
1358 
    result = getOrderCount_result()
1359 
    result.read(self._iprot)
1360 
    self._iprot.readMessageEnd()
1361 
    if result.success is not None:
1362 
      return result.success
1363 
    if result.ex is not None:
1364 
      raise result.ex
1365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1366 
 
999 varun.gupt 1367 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1368 
    """
1132 chandransh 1369 
    Returns orders within a range of their billing dates
3431 rajveer 1370 
 
999 varun.gupt 1371 
    Parameters:
1372 
     - status
1373 
     - start_billing_date
1374 
     - end_billing_date
1375 
     - warehouse_id
1376 
    """
1377 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1378 
    return self.recv_getOrdersByBillingDate()
1379 
 
1380 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1381 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1382 
    args = getOrdersByBillingDate_args()
1383 
    args.status = status
1384 
    args.start_billing_date = start_billing_date
1385 
    args.end_billing_date = end_billing_date
1386 
    args.warehouse_id = warehouse_id
1387 
    args.write(self._oprot)
1388 
    self._oprot.writeMessageEnd()
1389 
    self._oprot.trans.flush()
1390 
 
1391 
  def recv_getOrdersByBillingDate(self, ):
1392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1393 
    if mtype == TMessageType.EXCEPTION:
1394 
      x = TApplicationException()
1395 
      x.read(self._iprot)
1396 
      self._iprot.readMessageEnd()
1397 
      raise x
1398 
    result = getOrdersByBillingDate_result()
1399 
    result.read(self._iprot)
1400 
    self._iprot.readMessageEnd()
3431 rajveer 1401 
    if result.success is not None:
999 varun.gupt 1402 
      return result.success
3431 rajveer 1403 
    if result.ex is not None:
999 varun.gupt 1404 
      raise result.ex
1405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1406 
 
3451 chandransh 1407 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1408 
    """
1409 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1410 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1411 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1412 
 
3427 chandransh 1413 
    Parameters:
1414 
     - fromShippingDate
1415 
     - toShippingDate
1416 
     - providerId
1417 
     - warehouseId
3451 chandransh 1418 
     - cod
3427 chandransh 1419 
    """
3451 chandransh 1420 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1421 
    return self.recv_getOrdersByShippingDate()
1422 
 
3451 chandransh 1423 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1424 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1425 
    args = getOrdersByShippingDate_args()
1426 
    args.fromShippingDate = fromShippingDate
1427 
    args.toShippingDate = toShippingDate
1428 
    args.providerId = providerId
1429 
    args.warehouseId = warehouseId
3451 chandransh 1430 
    args.cod = cod
3427 chandransh 1431 
    args.write(self._oprot)
1432 
    self._oprot.writeMessageEnd()
1433 
    self._oprot.trans.flush()
1434 
 
1435 
  def recv_getOrdersByShippingDate(self, ):
1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1437 
    if mtype == TMessageType.EXCEPTION:
1438 
      x = TApplicationException()
1439 
      x.read(self._iprot)
1440 
      self._iprot.readMessageEnd()
1441 
      raise x
1442 
    result = getOrdersByShippingDate_result()
1443 
    result.read(self._iprot)
1444 
    self._iprot.readMessageEnd()
3431 rajveer 1445 
    if result.success is not None:
3427 chandransh 1446 
      return result.success
3431 rajveer 1447 
    if result.ex is not None:
3427 chandransh 1448 
      raise result.ex
1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1450 
 
1382 varun.gupt 1451 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1452 
    """
1453 
    Returns order ids for orders which can be returned
3431 rajveer 1454 
 
1382 varun.gupt 1455 
    Parameters:
1456 
     - customer_id
1457 
     - limit
1458 
    """
1459 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1460 
    return self.recv_getReturnableOrdersForCustomer()
1461 
 
1462 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1463 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1464 
    args = getReturnableOrdersForCustomer_args()
1465 
    args.customer_id = customer_id
1466 
    args.limit = limit
1467 
    args.write(self._oprot)
1468 
    self._oprot.writeMessageEnd()
1469 
    self._oprot.trans.flush()
1470 
 
1471 
  def recv_getReturnableOrdersForCustomer(self, ):
1472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1473 
    if mtype == TMessageType.EXCEPTION:
1474 
      x = TApplicationException()
1475 
      x.read(self._iprot)
1476 
      self._iprot.readMessageEnd()
1477 
      raise x
1478 
    result = getReturnableOrdersForCustomer_result()
1479 
    result.read(self._iprot)
1480 
    self._iprot.readMessageEnd()
3431 rajveer 1481 
    if result.success is not None:
1382 varun.gupt 1482 
      return result.success
3431 rajveer 1483 
    if result.ex is not None:
1382 varun.gupt 1484 
      raise result.ex
1485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1486 
 
1487 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1488 
    """
1489 
    Returns order ids for orders which can be cancelled
3431 rajveer 1490 
 
1382 varun.gupt 1491 
    Parameters:
1492 
     - customer_id
1493 
     - limit
1494 
    """
1495 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1496 
    return self.recv_getCancellableOrdersForCustomer()
1497 
 
1498 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1499 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1500 
    args = getCancellableOrdersForCustomer_args()
1501 
    args.customer_id = customer_id
1502 
    args.limit = limit
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_getCancellableOrdersForCustomer(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = getCancellableOrdersForCustomer_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
3431 rajveer 1517 
    if result.success is not None:
1382 varun.gupt 1518 
      return result.success
3431 rajveer 1519 
    if result.ex is not None:
1382 varun.gupt 1520 
      raise result.ex
1521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1522 
 
483 rajveer 1523 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1524 
    """
1525 
    Parameters:
483 rajveer 1526 
     - orderId
1527 
     - status
1528 
     - description
94 ashish 1529 
    """
483 rajveer 1530 
    self.send_changeOrderStatus(orderId, status, description)
1531 
    return self.recv_changeOrderStatus()
94 ashish 1532 
 
483 rajveer 1533 
  def send_changeOrderStatus(self, orderId, status, description):
1534 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1535 
    args = changeOrderStatus_args()
1536 
    args.orderId = orderId
1537 
    args.status = status
1538 
    args.description = description
94 ashish 1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
483 rajveer 1543 
  def recv_changeOrderStatus(self, ):
94 ashish 1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
483 rajveer 1550 
    result = changeOrderStatus_result()
94 ashish 1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
3431 rajveer 1553 
    if result.success is not None:
94 ashish 1554 
      return result.success
3431 rajveer 1555 
    if result.ex is not None:
94 ashish 1556 
      raise result.ex
483 rajveer 1557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1558 
 
1528 ankur.sing 1559 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1560 
    """
1528 ankur.sing 1561 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1562 
    only user who owns the transaction can view its order details.
3431 rajveer 1563 
 
94 ashish 1564 
    Parameters:
1565 
     - transactionId
1528 ankur.sing 1566 
     - customerId
94 ashish 1567 
    """
1528 ankur.sing 1568 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1569 
    return self.recv_getOrdersForTransaction()
94 ashish 1570 
 
1528 ankur.sing 1571 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1572 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1573 
    args = getOrdersForTransaction_args()
94 ashish 1574 
    args.transactionId = transactionId
1528 ankur.sing 1575 
    args.customerId = customerId
94 ashish 1576 
    args.write(self._oprot)
1577 
    self._oprot.writeMessageEnd()
1578 
    self._oprot.trans.flush()
1579 
 
483 rajveer 1580 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1582 
    if mtype == TMessageType.EXCEPTION:
1583 
      x = TApplicationException()
1584 
      x.read(self._iprot)
1585 
      self._iprot.readMessageEnd()
1586 
      raise x
483 rajveer 1587 
    result = getOrdersForTransaction_result()
94 ashish 1588 
    result.read(self._iprot)
1589 
    self._iprot.readMessageEnd()
3431 rajveer 1590 
    if result.success is not None:
94 ashish 1591 
      return result.success
3431 rajveer 1592 
    if result.ex is not None:
94 ashish 1593 
      raise result.ex
483 rajveer 1594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1595 
 
3014 chandransh 1596 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1597 
    """
3014 chandransh 1598 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1599 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1600 
 
94 ashish 1601 
    Parameters:
483 rajveer 1602 
     - customerId
1603 
     - from_date
1604 
     - to_date
3014 chandransh 1605 
     - statuses
94 ashish 1606 
    """
3014 chandransh 1607 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1608 
    return self.recv_getOrdersForCustomer()
94 ashish 1609 
 
3014 chandransh 1610 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1611 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1612 
    args = getOrdersForCustomer_args()
1613 
    args.customerId = customerId
1614 
    args.from_date = from_date
1615 
    args.to_date = to_date
3014 chandransh 1616 
    args.statuses = statuses
94 ashish 1617 
    args.write(self._oprot)
1618 
    self._oprot.writeMessageEnd()
1619 
    self._oprot.trans.flush()
1620 
 
483 rajveer 1621 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1623 
    if mtype == TMessageType.EXCEPTION:
1624 
      x = TApplicationException()
1625 
      x.read(self._iprot)
1626 
      self._iprot.readMessageEnd()
1627 
      raise x
483 rajveer 1628 
    result = getOrdersForCustomer_result()
94 ashish 1629 
    result.read(self._iprot)
1630 
    self._iprot.readMessageEnd()
3431 rajveer 1631 
    if result.success is not None:
94 ashish 1632 
      return result.success
3431 rajveer 1633 
    if result.ex is not None:
94 ashish 1634 
      raise result.ex
483 rajveer 1635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1636 
 
483 rajveer 1637 
  def createOrder(self, order):
94 ashish 1638 
    """
1639 
    Parameters:
483 rajveer 1640 
     - order
94 ashish 1641 
    """
483 rajveer 1642 
    self.send_createOrder(order)
1643 
    return self.recv_createOrder()
94 ashish 1644 
 
483 rajveer 1645 
  def send_createOrder(self, order):
1646 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1647 
    args = createOrder_args()
1648 
    args.order = order
94 ashish 1649 
    args.write(self._oprot)
1650 
    self._oprot.writeMessageEnd()
1651 
    self._oprot.trans.flush()
1652 
 
483 rajveer 1653 
  def recv_createOrder(self, ):
94 ashish 1654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1655 
    if mtype == TMessageType.EXCEPTION:
1656 
      x = TApplicationException()
1657 
      x.read(self._iprot)
1658 
      self._iprot.readMessageEnd()
1659 
      raise x
483 rajveer 1660 
    result = createOrder_result()
94 ashish 1661 
    result.read(self._iprot)
1662 
    self._iprot.readMessageEnd()
3431 rajveer 1663 
    if result.success is not None:
94 ashish 1664 
      return result.success
3431 rajveer 1665 
    if result.ex is not None:
94 ashish 1666 
      raise result.ex
483 rajveer 1667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1668 
 
483 rajveer 1669 
  def getOrder(self, id):
94 ashish 1670 
    """
1671 
    Parameters:
483 rajveer 1672 
     - id
94 ashish 1673 
    """
483 rajveer 1674 
    self.send_getOrder(id)
1675 
    return self.recv_getOrder()
94 ashish 1676 
 
483 rajveer 1677 
  def send_getOrder(self, id):
1678 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1679 
    args = getOrder_args()
1680 
    args.id = id
94 ashish 1681 
    args.write(self._oprot)
1682 
    self._oprot.writeMessageEnd()
1683 
    self._oprot.trans.flush()
1684 
 
483 rajveer 1685 
  def recv_getOrder(self, ):
94 ashish 1686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1687 
    if mtype == TMessageType.EXCEPTION:
1688 
      x = TApplicationException()
1689 
      x.read(self._iprot)
1690 
      self._iprot.readMessageEnd()
1691 
      raise x
483 rajveer 1692 
    result = getOrder_result()
94 ashish 1693 
    result.read(self._iprot)
1694 
    self._iprot.readMessageEnd()
3431 rajveer 1695 
    if result.success is not None:
94 ashish 1696 
      return result.success
3431 rajveer 1697 
    if result.ex is not None:
94 ashish 1698 
      raise result.ex
483 rajveer 1699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1700 
 
483 rajveer 1701 
  def getLineItemsForOrder(self, orderId):
94 ashish 1702 
    """
1703 
    Parameters:
483 rajveer 1704 
     - orderId
94 ashish 1705 
    """
483 rajveer 1706 
    self.send_getLineItemsForOrder(orderId)
1707 
    return self.recv_getLineItemsForOrder()
94 ashish 1708 
 
483 rajveer 1709 
  def send_getLineItemsForOrder(self, orderId):
1710 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1711 
    args = getLineItemsForOrder_args()
1712 
    args.orderId = orderId
94 ashish 1713 
    args.write(self._oprot)
1714 
    self._oprot.writeMessageEnd()
1715 
    self._oprot.trans.flush()
1716 
 
483 rajveer 1717 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1719 
    if mtype == TMessageType.EXCEPTION:
1720 
      x = TApplicationException()
1721 
      x.read(self._iprot)
1722 
      self._iprot.readMessageEnd()
1723 
      raise x
483 rajveer 1724 
    result = getLineItemsForOrder_result()
94 ashish 1725 
    result.read(self._iprot)
1726 
    self._iprot.readMessageEnd()
3431 rajveer 1727 
    if result.success is not None:
94 ashish 1728 
      return result.success
3431 rajveer 1729 
    if result.ex is not None:
94 ashish 1730 
      raise result.ex
483 rajveer 1731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1732 
 
1528 ankur.sing 1733 
  def getOrderForCustomer(self, orderId, customerId):
1734 
    """
1735 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1736 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1737 
 
1528 ankur.sing 1738 
    Parameters:
1739 
     - orderId
1740 
     - customerId
1741 
    """
1742 
    self.send_getOrderForCustomer(orderId, customerId)
1743 
    return self.recv_getOrderForCustomer()
1744 
 
1745 
  def send_getOrderForCustomer(self, orderId, customerId):
1746 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1747 
    args = getOrderForCustomer_args()
1748 
    args.orderId = orderId
1749 
    args.customerId = customerId
1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
1754 
  def recv_getOrderForCustomer(self, ):
1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
1761 
    result = getOrderForCustomer_result()
1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
3431 rajveer 1764 
    if result.success is not None:
1528 ankur.sing 1765 
      return result.success
3431 rajveer 1766 
    if result.ex is not None:
1528 ankur.sing 1767 
      raise result.ex
1768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1769 
 
4444 rajveer 1770 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1771 
    """
1772 
    Parameters:
4394 rajveer 1773 
     - type
4444 rajveer 1774 
     - warehouseId
4394 rajveer 1775 
     - status
1776 
     - timestamp
3064 chandransh 1777 
    """
4444 rajveer 1778 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1779 
    return self.recv_getAlerts()
1780 
 
4444 rajveer 1781 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1782 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1783 
    args = getAlerts_args()
4394 rajveer 1784 
    args.type = type
4444 rajveer 1785 
    args.warehouseId = warehouseId
4394 rajveer 1786 
    args.status = status
1787 
    args.timestamp = timestamp
3064 chandransh 1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
1792 
  def recv_getAlerts(self, ):
1793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1794 
    if mtype == TMessageType.EXCEPTION:
1795 
      x = TApplicationException()
1796 
      x.read(self._iprot)
1797 
      self._iprot.readMessageEnd()
1798 
      raise x
1799 
    result = getAlerts_result()
1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
3431 rajveer 1802 
    if result.success is not None:
3064 chandransh 1803 
      return result.success
1804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1805 
 
4444 rajveer 1806 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1807 
    """
1808 
    Parameters:
1809 
     - type
4444 rajveer 1810 
     - warehouseId
4394 rajveer 1811 
     - description
3064 chandransh 1812 
    """
4444 rajveer 1813 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1814 
    self.recv_addAlert()
3064 chandransh 1815 
 
4444 rajveer 1816 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1817 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1818 
    args = addAlert_args()
3064 chandransh 1819 
    args.type = type
4444 rajveer 1820 
    args.warehouseId = warehouseId
4394 rajveer 1821 
    args.description = description
3064 chandransh 1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
4394 rajveer 1826 
  def recv_addAlert(self, ):
3064 chandransh 1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
4394 rajveer 1833 
    result = addAlert_result()
3064 chandransh 1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    return
1837 
 
4444 rajveer 1838 
  def markAlertsAsSeen(self, warehouseId):
1839 
    """
1840 
    Parameters:
1841 
     - warehouseId
1842 
    """
1843 
    self.send_markAlertsAsSeen(warehouseId)
1844 
    self.recv_markAlertsAsSeen()
1845 
 
1846 
  def send_markAlertsAsSeen(self, warehouseId):
1847 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1848 
    args = markAlertsAsSeen_args()
1849 
    args.warehouseId = warehouseId
1850 
    args.write(self._oprot)
1851 
    self._oprot.writeMessageEnd()
1852 
    self._oprot.trans.flush()
1853 
 
1854 
  def recv_markAlertsAsSeen(self, ):
1855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1856 
    if mtype == TMessageType.EXCEPTION:
1857 
      x = TApplicationException()
1858 
      x.read(self._iprot)
1859 
      self._iprot.readMessageEnd()
1860 
      raise x
1861 
    result = markAlertsAsSeen_result()
1862 
    result.read(self._iprot)
1863 
    self._iprot.readMessageEnd()
1864 
    return
1865 
 
3064 chandransh 1866 
  def getValidOrderCount(self, ):
1867 
    """
1868 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1869 
    """
1870 
    self.send_getValidOrderCount()
1871 
    return self.recv_getValidOrderCount()
1872 
 
1873 
  def send_getValidOrderCount(self, ):
1874 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1875 
    args = getValidOrderCount_args()
1876 
    args.write(self._oprot)
1877 
    self._oprot.writeMessageEnd()
1878 
    self._oprot.trans.flush()
1879 
 
1880 
  def recv_getValidOrderCount(self, ):
1881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1882 
    if mtype == TMessageType.EXCEPTION:
1883 
      x = TApplicationException()
1884 
      x.read(self._iprot)
1885 
      self._iprot.readMessageEnd()
1886 
      raise x
1887 
    result = getValidOrderCount_result()
1888 
    result.read(self._iprot)
1889 
    self._iprot.readMessageEnd()
3431 rajveer 1890 
    if result.success is not None:
3064 chandransh 1891 
      return result.success
1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1893 
 
1894 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1895 
    """
1896 
    Returns the number of distinct customers who have done successful transactions
1897 
    """
1898 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1899 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1900 
 
1901 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1902 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1903 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1904 
    args.write(self._oprot)
1905 
    self._oprot.writeMessageEnd()
1906 
    self._oprot.trans.flush()
1907 
 
1908 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1910 
    if mtype == TMessageType.EXCEPTION:
1911 
      x = TApplicationException()
1912 
      x.read(self._iprot)
1913 
      self._iprot.readMessageEnd()
1914 
      raise x
1915 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1916 
    result.read(self._iprot)
1917 
    self._iprot.readMessageEnd()
3431 rajveer 1918 
    if result.success is not None:
3064 chandransh 1919 
      return result.success
1920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1921 
 
1922 
  def getValidOrdersAmountRange(self, ):
1923 
    """
1924 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1925 
    List contains two values, first minimum amount and second maximum amount.
1926 
    """
1927 
    self.send_getValidOrdersAmountRange()
1928 
    return self.recv_getValidOrdersAmountRange()
1929 
 
1930 
  def send_getValidOrdersAmountRange(self, ):
1931 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1932 
    args = getValidOrdersAmountRange_args()
1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
1937 
  def recv_getValidOrdersAmountRange(self, ):
1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
1944 
    result = getValidOrdersAmountRange_result()
1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
3431 rajveer 1947 
    if result.success is not None:
3064 chandransh 1948 
      return result.success
1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1950 
 
1951 
  def getValidOrders(self, limit):
1952 
    """
1953 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1954 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1955 
 
3064 chandransh 1956 
    Parameters:
1957 
     - limit
1958 
    """
1959 
    self.send_getValidOrders(limit)
1960 
    return self.recv_getValidOrders()
1961 
 
1962 
  def send_getValidOrders(self, limit):
1963 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1964 
    args = getValidOrders_args()
1965 
    args.limit = limit
1966 
    args.write(self._oprot)
1967 
    self._oprot.writeMessageEnd()
1968 
    self._oprot.trans.flush()
1969 
 
1970 
  def recv_getValidOrders(self, ):
1971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1972 
    if mtype == TMessageType.EXCEPTION:
1973 
      x = TApplicationException()
1974 
      x.read(self._iprot)
1975 
      self._iprot.readMessageEnd()
1976 
      raise x
1977 
    result = getValidOrders_result()
1978 
    result.read(self._iprot)
1979 
    self._iprot.readMessageEnd()
3431 rajveer 1980 
    if result.success is not None:
3064 chandransh 1981 
      return result.success
1982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1983 
 
1220 chandransh 1984 
  def batchOrders(self, warehouseId):
1985 
    """
1986 
    Create a batch of all the pending orders for the given warehouse.
1987 
    The returned list is orderd by created_timestamp.
1988 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1989 
 
1220 chandransh 1990 
    Parameters:
1991 
     - warehouseId
1992 
    """
1993 
    self.send_batchOrders(warehouseId)
1994 
    return self.recv_batchOrders()
1995 
 
1996 
  def send_batchOrders(self, warehouseId):
1997 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1998 
    args = batchOrders_args()
1999 
    args.warehouseId = warehouseId
2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_batchOrders(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = batchOrders_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
3431 rajveer 2014 
    if result.success is not None:
1220 chandransh 2015 
      return result.success
3431 rajveer 2016 
    if result.ex is not None:
1220 chandransh 2017 
      raise result.ex
2018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2019 
 
1208 chandransh 2020 
  def markOrderAsOutOfStock(self, orderId):
2021 
    """
2022 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2023 
 
1208 chandransh 2024 
    Parameters:
2025 
     - orderId
2026 
    """
2027 
    self.send_markOrderAsOutOfStock(orderId)
2028 
    return self.recv_markOrderAsOutOfStock()
2029 
 
2030 
  def send_markOrderAsOutOfStock(self, orderId):
2031 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2032 
    args = markOrderAsOutOfStock_args()
2033 
    args.orderId = orderId
2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
2038 
  def recv_markOrderAsOutOfStock(self, ):
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
2045 
    result = markOrderAsOutOfStock_result()
2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
3431 rajveer 2048 
    if result.success is not None:
1208 chandransh 2049 
      return result.success
3431 rajveer 2050 
    if result.ex is not None:
1208 chandransh 2051 
      raise result.ex
2052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2053 
 
3064 chandransh 2054 
  def verifyOrder(self, orderId):
759 chandransh 2055 
    """
3064 chandransh 2056 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2057 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2058 
    used for all other orders as well.
2059 
    Throws an exception if no such order exists.
3431 rajveer 2060 
 
759 chandransh 2061 
    Parameters:
3064 chandransh 2062 
     - orderId
759 chandransh 2063 
    """
3064 chandransh 2064 
    self.send_verifyOrder(orderId)
2065 
    return self.recv_verifyOrder()
759 chandransh 2066 
 
3064 chandransh 2067 
  def send_verifyOrder(self, orderId):
2068 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2069 
    args = verifyOrder_args()
2070 
    args.orderId = orderId
759 chandransh 2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
3064 chandransh 2075 
  def recv_verifyOrder(self, ):
759 chandransh 2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
3064 chandransh 2082 
    result = verifyOrder_result()
759 chandransh 2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
3431 rajveer 2085 
    if result.success is not None:
759 chandransh 2086 
      return result.success
3431 rajveer 2087 
    if result.ex is not None:
759 chandransh 2088 
      raise result.ex
3064 chandransh 2089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2090 
 
3064 chandransh 2091 
  def acceptOrder(self, orderId):
1113 chandransh 2092 
    """
3064 chandransh 2093 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2094 
    given order is not a COD order, it also captures the payment if the same has
2095 
    not been captured.
2096 
    Throws an exception if no such order exists.
3431 rajveer 2097 
 
1113 chandransh 2098 
    Parameters:
3064 chandransh 2099 
     - orderId
1113 chandransh 2100 
    """
3064 chandransh 2101 
    self.send_acceptOrder(orderId)
2102 
    return self.recv_acceptOrder()
1113 chandransh 2103 
 
3064 chandransh 2104 
  def send_acceptOrder(self, orderId):
2105 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2106 
    args = acceptOrder_args()
2107 
    args.orderId = orderId
1113 chandransh 2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
3064 chandransh 2112 
  def recv_acceptOrder(self, ):
1113 chandransh 2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
3064 chandransh 2119 
    result = acceptOrder_result()
1113 chandransh 2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
3431 rajveer 2122 
    if result.success is not None:
1113 chandransh 2123 
      return result.success
3431 rajveer 2124 
    if result.ex is not None:
1113 chandransh 2125 
      raise result.ex
3064 chandransh 2126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2127 
 
4658 mandeep.dh 2128 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2129 
    """
3064 chandransh 2130 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2131 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2132 
    the IMEI no. if a -1 is supplied.
2133 
    Also, it generates an invoice number for the order, marks the order as
2134 
    BILLED and sets the billing timestamp.
2135 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2136 
 
1135 chandransh 2137 
    Parameters:
3064 chandransh 2138 
     - orderId
2139 
     - invoice_number
4658 mandeep.dh 2140 
     - serialNumber
4283 anupam.sin 2141 
     - itemNumber
3064 chandransh 2142 
     - billed_by
4264 rajveer 2143 
     - jacketNumber
4283 anupam.sin 2144 
     - billingType
2145 
     - vendorId
1135 chandransh 2146 
    """
4658 mandeep.dh 2147 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2148 
    return self.recv_addBillingDetails()
1135 chandransh 2149 
 
4658 mandeep.dh 2150 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2151 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2152 
    args = addBillingDetails_args()
2153 
    args.orderId = orderId
2154 
    args.invoice_number = invoice_number
4658 mandeep.dh 2155 
    args.serialNumber = serialNumber
4283 anupam.sin 2156 
    args.itemNumber = itemNumber
3064 chandransh 2157 
    args.billed_by = billed_by
4264 rajveer 2158 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2159 
    args.billingType = billingType
2160 
    args.vendorId = vendorId
1135 chandransh 2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
3064 chandransh 2165 
  def recv_addBillingDetails(self, ):
1135 chandransh 2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
3064 chandransh 2172 
    result = addBillingDetails_result()
1135 chandransh 2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
3431 rajveer 2175 
    if result.success is not None:
3064 chandransh 2176 
      return result.success
3431 rajveer 2177 
    if result.ex is not None:
1135 chandransh 2178 
      raise result.ex
3064 chandransh 2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2180 
 
4579 rajveer 2181 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2182 
    """
2183 
    Add the invoice number to the order.
2184 
 
2185 
    Parameters:
2186 
     - orderId
2187 
     - invoiceNumber
2188 
    """
2189 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2190 
    self.recv_addInvoiceNumber()
2191 
 
2192 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2193 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2194 
    args = addInvoiceNumber_args()
2195 
    args.orderId = orderId
2196 
    args.invoiceNumber = invoiceNumber
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_addInvoiceNumber(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = addInvoiceNumber_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.ex is not None:
2212 
      raise result.ex
2213 
    return
2214 
 
3064 chandransh 2215 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2216 
    """
3064 chandransh 2217 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2218 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2219 
 
1408 ankur.sing 2220 
    Parameters:
3064 chandransh 2221 
     - warehouseId
1408 ankur.sing 2222 
     - providerId
3064 chandransh 2223 
     - cod
1408 ankur.sing 2224 
    """
3064 chandransh 2225 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2226 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2227 
 
3064 chandransh 2228 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2229 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2230 
    args = markOrdersAsManifested_args()
2231 
    args.warehouseId = warehouseId
1408 ankur.sing 2232 
    args.providerId = providerId
3064 chandransh 2233 
    args.cod = cod
1408 ankur.sing 2234 
    args.write(self._oprot)
2235 
    self._oprot.writeMessageEnd()
2236 
    self._oprot.trans.flush()
2237 
 
3064 chandransh 2238 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2240 
    if mtype == TMessageType.EXCEPTION:
2241 
      x = TApplicationException()
2242 
      x.read(self._iprot)
2243 
      self._iprot.readMessageEnd()
2244 
      raise x
3064 chandransh 2245 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2246 
    result.read(self._iprot)
2247 
    self._iprot.readMessageEnd()
3431 rajveer 2248 
    if result.success is not None:
1408 ankur.sing 2249 
      return result.success
3431 rajveer 2250 
    if result.ex is not None:
3064 chandransh 2251 
      raise result.ex
2252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2253 
 
4410 rajveer 2254 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2255 
    """
2256 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2257 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2258 
 
2259 
    Parameters:
2260 
     - warehouseId
2261 
     - providerId
2262 
     - cod
2263 
    """
2264 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2265 
    return self.recv_markOrdersAsShippedFromWarehouse()
2266 
 
2267 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2268 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2269 
    args = markOrdersAsShippedFromWarehouse_args()
2270 
    args.warehouseId = warehouseId
2271 
    args.providerId = providerId
2272 
    args.cod = cod
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = markOrdersAsShippedFromWarehouse_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.success is not None:
2288 
      return result.success
2289 
    if result.ex is not None:
2290 
      raise result.ex
2291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2292 
 
3064 chandransh 2293 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2294 
    """
3064 chandransh 2295 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2296 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2297 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2298 
 
94 ashish 2299 
    Parameters:
3064 chandransh 2300 
     - providerId
2301 
     - pickupDetails
304 ashish 2302 
    """
3064 chandransh 2303 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2304 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2305 
 
3064 chandransh 2306 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2307 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2308 
    args = markOrdersAsPickedUp_args()
2309 
    args.providerId = providerId
2310 
    args.pickupDetails = pickupDetails
304 ashish 2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
3064 chandransh 2315 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
3064 chandransh 2322 
    result = markOrdersAsPickedUp_result()
304 ashish 2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
3431 rajveer 2325 
    if result.success is not None:
304 ashish 2326 
      return result.success
3431 rajveer 2327 
    if result.ex is not None:
3064 chandransh 2328 
      raise result.ex
2329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2330 
 
3064 chandransh 2331 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2332 
    """
3064 chandransh 2333 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2334 
    the name of the receiver.
2335 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2336 
 
304 ashish 2337 
    Parameters:
3064 chandransh 2338 
     - providerId
2339 
     - deliveredOrders
304 ashish 2340 
    """
3064 chandransh 2341 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2342 
    self.recv_markOrdersAsDelivered()
304 ashish 2343 
 
3064 chandransh 2344 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2345 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2346 
    args = markOrdersAsDelivered_args()
2347 
    args.providerId = providerId
2348 
    args.deliveredOrders = deliveredOrders
304 ashish 2349 
    args.write(self._oprot)
2350 
    self._oprot.writeMessageEnd()
2351 
    self._oprot.trans.flush()
2352 
 
3064 chandransh 2353 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2355 
    if mtype == TMessageType.EXCEPTION:
2356 
      x = TApplicationException()
2357 
      x.read(self._iprot)
2358 
      self._iprot.readMessageEnd()
2359 
      raise x
3064 chandransh 2360 
    result = markOrdersAsDelivered_result()
304 ashish 2361 
    result.read(self._iprot)
2362 
    self._iprot.readMessageEnd()
3431 rajveer 2363 
    if result.ex is not None:
3064 chandransh 2364 
      raise result.ex
304 ashish 2365 
    return
2366 
 
3064 chandransh 2367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2368 
    """
3064 chandransh 2369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2371 
 
3064 chandransh 2372 
    Parameters:
2373 
     - providerId
2374 
     - returnedOrders
1596 ankur.sing 2375 
    """
3064 chandransh 2376 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2377 
    self.recv_markOrdersAsFailed()
304 ashish 2378 
 
3064 chandransh 2379 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2380 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2381 
    args = markOrdersAsFailed_args()
2382 
    args.providerId = providerId
2383 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
3064 chandransh 2388 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
3064 chandransh 2395 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
3431 rajveer 2398 
    if result.ex is not None:
3064 chandransh 2399 
      raise result.ex
2400 
    return
1596 ankur.sing 2401 
 
3064 chandransh 2402 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2403 
    """
3064 chandransh 2404 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2405 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2406 
 
3064 chandransh 2407 
    Parameters:
2408 
     - providerId
2409 
     - undeliveredOrders
1627 ankur.sing 2410 
    """
3064 chandransh 2411 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2412 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2413 
 
3064 chandransh 2414 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2415 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2416 
    args = updateNonDeliveryReason_args()
2417 
    args.providerId = providerId
2418 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2419 
    args.write(self._oprot)
2420 
    self._oprot.writeMessageEnd()
2421 
    self._oprot.trans.flush()
2422 
 
3064 chandransh 2423 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2425 
    if mtype == TMessageType.EXCEPTION:
2426 
      x = TApplicationException()
2427 
      x.read(self._iprot)
2428 
      self._iprot.readMessageEnd()
2429 
      raise x
3064 chandransh 2430 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2431 
    result.read(self._iprot)
2432 
    self._iprot.readMessageEnd()
4581 phani.kuma 2433 
    if result.success is not None:
2434 
      return result.success
3431 rajveer 2435 
    if result.ex is not None:
3064 chandransh 2436 
      raise result.ex
4581 phani.kuma 2437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2438 
 
3064 chandransh 2439 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2440 
    """
3064 chandransh 2441 
    Returns the list of orders whose delivery time has passed but have not been
2442 
    delivered yet for the given provider and warehouse. To get a complete list of
2443 
    undelivered orders, pass them as -1.
2444 
    Returns an empty list if no such orders exist.
3431 rajveer 2445 
 
1886 ankur.sing 2446 
    Parameters:
3064 chandransh 2447 
     - providerId
2448 
     - warehouseId
1886 ankur.sing 2449 
    """
3064 chandransh 2450 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2451 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2452 
 
3064 chandransh 2453 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2454 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2455 
    args = getUndeliveredOrders_args()
2456 
    args.providerId = providerId
2457 
    args.warehouseId = warehouseId
1886 ankur.sing 2458 
    args.write(self._oprot)
2459 
    self._oprot.writeMessageEnd()
2460 
    self._oprot.trans.flush()
2461 
 
3064 chandransh 2462 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2464 
    if mtype == TMessageType.EXCEPTION:
2465 
      x = TApplicationException()
2466 
      x.read(self._iprot)
2467 
      self._iprot.readMessageEnd()
2468 
      raise x
3064 chandransh 2469 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2470 
    result.read(self._iprot)
2471 
    self._iprot.readMessageEnd()
3431 rajveer 2472 
    if result.success is not None:
1886 ankur.sing 2473 
      return result.success
3064 chandransh 2474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2475 
 
2536 chandransh 2476 
  def toggleDOAFlag(self, orderId):
2477 
    """
2478 
    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.
2479 
    Returns the final flag status.
2480 
    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 2481 
 
2536 chandransh 2482 
    Parameters:
2483 
     - orderId
2484 
    """
2485 
    self.send_toggleDOAFlag(orderId)
2486 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2487 
 
2536 chandransh 2488 
  def send_toggleDOAFlag(self, orderId):
2489 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2490 
    args = toggleDOAFlag_args()
2491 
    args.orderId = orderId
2492 
    args.write(self._oprot)
2493 
    self._oprot.writeMessageEnd()
2494 
    self._oprot.trans.flush()
2495 
 
2496 
  def recv_toggleDOAFlag(self, ):
2497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2498 
    if mtype == TMessageType.EXCEPTION:
2499 
      x = TApplicationException()
2500 
      x.read(self._iprot)
2501 
      self._iprot.readMessageEnd()
2502 
      raise x
2503 
    result = toggleDOAFlag_result()
2504 
    result.read(self._iprot)
2505 
    self._iprot.readMessageEnd()
3431 rajveer 2506 
    if result.success is not None:
2536 chandransh 2507 
      return result.success
3431 rajveer 2508 
    if result.ex is not None:
2536 chandransh 2509 
      raise result.ex
2510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2511 
 
4712 rajveer 2512 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2513 
    """
2514 
    Parameters:
2515 
     - orderId
2516 
     - deliveryTimestamp
2517 
     - receiver
2518 
    """
2519 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2520 
    self.recv_markOrderAsDelivered()
2521 
 
2522 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2523 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2524 
    args = markOrderAsDelivered_args()
2525 
    args.orderId = orderId
2526 
    args.deliveryTimestamp = deliveryTimestamp
2527 
    args.receiver = receiver
2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_markOrderAsDelivered(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = markOrderAsDelivered_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
2542 
    if result.ex is not None:
2543 
      raise result.ex
2544 
    return
2545 
 
4454 rajveer 2546 
  def markOrderDoaRequestReceived(self, orderId):
2547 
    """
2548 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2549 
 
2550 
    Parameters:
2551 
     - orderId
2552 
    """
2553 
    self.send_markOrderDoaRequestReceived(orderId)
2554 
    return self.recv_markOrderDoaRequestReceived()
2555 
 
2556 
  def send_markOrderDoaRequestReceived(self, orderId):
2557 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2558 
    args = markOrderDoaRequestReceived_args()
2559 
    args.orderId = orderId
2560 
    args.write(self._oprot)
2561 
    self._oprot.writeMessageEnd()
2562 
    self._oprot.trans.flush()
2563 
 
2564 
  def recv_markOrderDoaRequestReceived(self, ):
2565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2566 
    if mtype == TMessageType.EXCEPTION:
2567 
      x = TApplicationException()
2568 
      x.read(self._iprot)
2569 
      self._iprot.readMessageEnd()
2570 
      raise x
2571 
    result = markOrderDoaRequestReceived_result()
2572 
    result.read(self._iprot)
2573 
    self._iprot.readMessageEnd()
2574 
    if result.success is not None:
2575 
      return result.success
2576 
    if result.ex is not None:
2577 
      raise result.ex
2578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2579 
 
2580 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2581 
    """
2582 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2583 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2584 
 
2585 
    Parameters:
2586 
     - orderId
2587 
     - isAuthorized
2588 
    """
2589 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2590 
    return self.recv_markOrderDoaRequestAuthorized()
2591 
 
2592 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2593 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2594 
    args = markOrderDoaRequestAuthorized_args()
2595 
    args.orderId = orderId
2596 
    args.isAuthorized = isAuthorized
2597 
    args.write(self._oprot)
2598 
    self._oprot.writeMessageEnd()
2599 
    self._oprot.trans.flush()
2600 
 
2601 
  def recv_markOrderDoaRequestAuthorized(self, ):
2602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2603 
    if mtype == TMessageType.EXCEPTION:
2604 
      x = TApplicationException()
2605 
      x.read(self._iprot)
2606 
      self._iprot.readMessageEnd()
2607 
      raise x
2608 
    result = markOrderDoaRequestAuthorized_result()
2609 
    result.read(self._iprot)
2610 
    self._iprot.readMessageEnd()
2611 
    if result.success is not None:
2612 
      return result.success
2613 
    if result.ex is not None:
2614 
      raise result.ex
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2616 
 
4488 rajveer 2617 
  def markOrderReturnRequestReceived(self, orderId):
2618 
    """
2619 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2620 
 
2621 
    Parameters:
2622 
     - orderId
2623 
    """
2624 
    self.send_markOrderReturnRequestReceived(orderId)
2625 
    return self.recv_markOrderReturnRequestReceived()
2626 
 
2627 
  def send_markOrderReturnRequestReceived(self, orderId):
2628 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2629 
    args = markOrderReturnRequestReceived_args()
2630 
    args.orderId = orderId
2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
2635 
  def recv_markOrderReturnRequestReceived(self, ):
2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
2642 
    result = markOrderReturnRequestReceived_result()
2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    if result.success is not None:
2646 
      return result.success
2647 
    if result.ex is not None:
2648 
      raise result.ex
2649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2650 
 
2651 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2652 
    """
2653 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2654 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2655 
 
2656 
    Parameters:
2657 
     - orderId
2658 
     - isAuthorized
2659 
    """
2660 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2661 
    return self.recv_markOrderReturnRequestAuthorized()
2662 
 
2663 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2664 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2665 
    args = markOrderReturnRequestAuthorized_args()
2666 
    args.orderId = orderId
2667 
    args.isAuthorized = isAuthorized
2668 
    args.write(self._oprot)
2669 
    self._oprot.writeMessageEnd()
2670 
    self._oprot.trans.flush()
2671 
 
2672 
  def recv_markOrderReturnRequestAuthorized(self, ):
2673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2674 
    if mtype == TMessageType.EXCEPTION:
2675 
      x = TApplicationException()
2676 
      x.read(self._iprot)
2677 
      self._iprot.readMessageEnd()
2678 
      raise x
2679 
    result = markOrderReturnRequestAuthorized_result()
2680 
    result.read(self._iprot)
2681 
    self._iprot.readMessageEnd()
2682 
    if result.success is not None:
2683 
      return result.success
2684 
    if result.ex is not None:
2685 
      raise result.ex
2686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2687 
 
4579 rajveer 2688 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2689 
    """
2690 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2691 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2692 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2693 
    For any other status, it returns false.
2694 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2695 
 
2536 chandransh 2696 
    Parameters:
2697 
     - orderId
4579 rajveer 2698 
     - providerId
2536 chandransh 2699 
    """
4579 rajveer 2700 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2701 
    return self.recv_requestPickupNumber()
2702 
 
4579 rajveer 2703 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2704 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2705 
    args = requestPickupNumber_args()
2706 
    args.orderId = orderId
4579 rajveer 2707 
    args.providerId = providerId
2536 chandransh 2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2712 
  def recv_requestPickupNumber(self, ):
2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2719 
    result = requestPickupNumber_result()
2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
3431 rajveer 2722 
    if result.success is not None:
2536 chandransh 2723 
      return result.success
3431 rajveer 2724 
    if result.ex is not None:
2536 chandransh 2725 
      raise result.ex
2726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2727 
 
4602 rajveer 2728 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2729 
    """
4452 rajveer 2730 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2731 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2732 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2733 
    	3. Returns true
2591 chandransh 2734 
    If the order is in any other status, it returns false.
2536 chandransh 2735 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2736 
 
2536 chandransh 2737 
    Parameters:
2738 
     - orderId
2739 
     - pickupNumber
4602 rajveer 2740 
     - providerId
2536 chandransh 2741 
    """
4602 rajveer 2742 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2743 
    return self.recv_authorizePickup()
2744 
 
4602 rajveer 2745 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2746 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2747 
    args = authorizePickup_args()
2748 
    args.orderId = orderId
2749 
    args.pickupNumber = pickupNumber
4602 rajveer 2750 
    args.providerId = providerId
2536 chandransh 2751 
    args.write(self._oprot)
2752 
    self._oprot.writeMessageEnd()
2753 
    self._oprot.trans.flush()
2754 
 
2755 
  def recv_authorizePickup(self, ):
2756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2757 
    if mtype == TMessageType.EXCEPTION:
2758 
      x = TApplicationException()
2759 
      x.read(self._iprot)
2760 
      self._iprot.readMessageEnd()
2761 
      raise x
2762 
    result = authorizePickup_result()
2763 
    result.read(self._iprot)
2764 
    self._iprot.readMessageEnd()
3431 rajveer 2765 
    if result.success is not None:
2536 chandransh 2766 
      return result.success
3431 rajveer 2767 
    if result.ex is not None:
2536 chandransh 2768 
      raise result.ex
2769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2770 
 
2764 chandransh 2771 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2772 
    """
2773 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2774 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2775 
 
2764 chandransh 2776 
    Parameters:
2777 
     - providerId
2778 
     - pickupDetails
2779 
    """
2780 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2781 
    return self.recv_markDoasAsPickedUp()
2782 
 
2783 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2784 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2785 
    args = markDoasAsPickedUp_args()
2786 
    args.providerId = providerId
2787 
    args.pickupDetails = pickupDetails
2788 
    args.write(self._oprot)
2789 
    self._oprot.writeMessageEnd()
2790 
    self._oprot.trans.flush()
2791 
 
2792 
  def recv_markDoasAsPickedUp(self, ):
2793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2794 
    if mtype == TMessageType.EXCEPTION:
2795 
      x = TApplicationException()
2796 
      x.read(self._iprot)
2797 
      self._iprot.readMessageEnd()
2798 
      raise x
2799 
    result = markDoasAsPickedUp_result()
2800 
    result.read(self._iprot)
2801 
    self._iprot.readMessageEnd()
3431 rajveer 2802 
    if result.success is not None:
2764 chandransh 2803 
      return result.success
2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2805 
 
4741 phani.kuma 2806 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2807 
    """
2808 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2809 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2810 
 
2811 
    Parameters:
2812 
     - providerId
2813 
     - pickupDetails
2814 
    """
2815 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2816 
    return self.recv_markReturnOrdersAsPickedUp()
2817 
 
2818 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2819 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2820 
    args = markReturnOrdersAsPickedUp_args()
2821 
    args.providerId = providerId
2822 
    args.pickupDetails = pickupDetails
2823 
    args.write(self._oprot)
2824 
    self._oprot.writeMessageEnd()
2825 
    self._oprot.trans.flush()
2826 
 
2827 
  def recv_markReturnOrdersAsPickedUp(self, ):
2828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2829 
    if mtype == TMessageType.EXCEPTION:
2830 
      x = TApplicationException()
2831 
      x.read(self._iprot)
2832 
      self._iprot.readMessageEnd()
2833 
      raise x
2834 
    result = markReturnOrdersAsPickedUp_result()
2835 
    result.read(self._iprot)
2836 
    self._iprot.readMessageEnd()
2837 
    if result.success is not None:
2838 
      return result.success
2839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2840 
 
4479 rajveer 2841 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2842 
    """
4452 rajveer 2843 
    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 2844 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2845 
    If the order is in any other state, it returns false.
2846 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2847 
 
2591 chandransh 2848 
    Parameters:
2849 
     - orderId
4479 rajveer 2850 
     - receiveCondition
2591 chandransh 2851 
    """
4479 rajveer 2852 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2853 
    return self.recv_receiveReturn()
2536 chandransh 2854 
 
4479 rajveer 2855 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2856 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2857 
    args = receiveReturn_args()
2591 chandransh 2858 
    args.orderId = orderId
4479 rajveer 2859 
    args.receiveCondition = receiveCondition
2591 chandransh 2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2616 chandransh 2864 
  def recv_receiveReturn(self, ):
2591 chandransh 2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2616 chandransh 2871 
    result = receiveReturn_result()
2591 chandransh 2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
3431 rajveer 2874 
    if result.success is not None:
2591 chandransh 2875 
      return result.success
3431 rajveer 2876 
    if result.ex is not None:
2591 chandransh 2877 
      raise result.ex
2616 chandransh 2878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2879 
 
2880 
  def validateDoa(self, orderId, isValid):
2881 
    """
4452 rajveer 2882 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2883 
    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 2884 
    If the order is in any other state, it returns false.
2885 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2886 
 
2591 chandransh 2887 
    Parameters:
2888 
     - orderId
2889 
     - isValid
2890 
    """
2891 
    self.send_validateDoa(orderId, isValid)
2892 
    return self.recv_validateDoa()
2893 
 
2894 
  def send_validateDoa(self, orderId, isValid):
2895 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2896 
    args = validateDoa_args()
2897 
    args.orderId = orderId
2898 
    args.isValid = isValid
2899 
    args.write(self._oprot)
2900 
    self._oprot.writeMessageEnd()
2901 
    self._oprot.trans.flush()
2902 
 
2903 
  def recv_validateDoa(self, ):
2904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2905 
    if mtype == TMessageType.EXCEPTION:
2906 
      x = TApplicationException()
2907 
      x.read(self._iprot)
2908 
      self._iprot.readMessageEnd()
2909 
      raise x
2910 
    result = validateDoa_result()
2911 
    result.read(self._iprot)
2912 
    self._iprot.readMessageEnd()
3431 rajveer 2913 
    if result.success is not None:
2591 chandransh 2914 
      return result.success
3431 rajveer 2915 
    if result.ex is not None:
2591 chandransh 2916 
      raise result.ex
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2918 
 
4495 rajveer 2919 
  def validateReturnProduct(self, orderId, isUsable):
2920 
    """
2921 
    Parameters:
2922 
     - orderId
2923 
     - isUsable
2924 
    """
2925 
    self.send_validateReturnProduct(orderId, isUsable)
2926 
    return self.recv_validateReturnProduct()
2927 
 
2928 
  def send_validateReturnProduct(self, orderId, isUsable):
2929 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2930 
    args = validateReturnProduct_args()
2931 
    args.orderId = orderId
2932 
    args.isUsable = isUsable
2933 
    args.write(self._oprot)
2934 
    self._oprot.writeMessageEnd()
2935 
    self._oprot.trans.flush()
2936 
 
2937 
  def recv_validateReturnProduct(self, ):
2938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2939 
    if mtype == TMessageType.EXCEPTION:
2940 
      x = TApplicationException()
2941 
      x.read(self._iprot)
2942 
      self._iprot.readMessageEnd()
2943 
      raise x
2944 
    result = validateReturnProduct_result()
2945 
    result.read(self._iprot)
2946 
    self._iprot.readMessageEnd()
2947 
    if result.success is not None:
2948 
      return result.success
2949 
    if result.ex is not None:
2950 
      raise result.ex
2951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2952 
 
2616 chandransh 2953 
  def reshipOrder(self, orderId):
2954 
    """
4484 rajveer 2955 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2956 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2957 
    	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 2958 
 
2959 
    If the order is in DOA_CERT_VALID state, it does the following:
2960 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2961 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2962 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2963 
 
2616 chandransh 2964 
    Returns the id of the newly created order.
3431 rajveer 2965 
 
2616 chandransh 2966 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2967 
 
2616 chandransh 2968 
    Parameters:
2969 
     - orderId
2970 
    """
2971 
    self.send_reshipOrder(orderId)
2972 
    return self.recv_reshipOrder()
2591 chandransh 2973 
 
2616 chandransh 2974 
  def send_reshipOrder(self, orderId):
2975 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2976 
    args = reshipOrder_args()
2977 
    args.orderId = orderId
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_reshipOrder(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = reshipOrder_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
3431 rajveer 2992 
    if result.success is not None:
2616 chandransh 2993 
      return result.success
3431 rajveer 2994 
    if result.ex is not None:
2616 chandransh 2995 
      raise result.ex
2996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2997 
 
3226 chandransh 2998 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2999 
    """
4484 rajveer 3000 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3001 
    	1. Creates a refund request for batch processing.
3002 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3003 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3004 
 
2616 chandransh 3005 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3006 
    	1. Creates a refund request for batch processing.
3226 chandransh 3007 
    	2. Cancels the reservation of the item in the warehouse.
3008 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3009 
 
3226 chandransh 3010 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3011 
    	1. Cancels the reservation of the item in the warehouse.
3012 
    	2. Marks the current order as CANCELED.
3013 
 
3014 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3015 
 
2616 chandransh 3016 
    Returns True if it is successful, False otherwise.
3431 rajveer 3017 
 
2616 chandransh 3018 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3019 
 
2616 chandransh 3020 
    Parameters:
3021 
     - orderId
3226 chandransh 3022 
     - refundedBy
3023 
     - reason
2616 chandransh 3024 
    """
3226 chandransh 3025 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3026 
    return self.recv_refundOrder()
3027 
 
3226 chandransh 3028 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3029 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3030 
    args = refundOrder_args()
3031 
    args.orderId = orderId
3226 chandransh 3032 
    args.refundedBy = refundedBy
3033 
    args.reason = reason
2616 chandransh 3034 
    args.write(self._oprot)
3035 
    self._oprot.writeMessageEnd()
3036 
    self._oprot.trans.flush()
3037 
 
3038 
  def recv_refundOrder(self, ):
3039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3040 
    if mtype == TMessageType.EXCEPTION:
3041 
      x = TApplicationException()
3042 
      x.read(self._iprot)
3043 
      self._iprot.readMessageEnd()
3044 
      raise x
3045 
    result = refundOrder_result()
3046 
    result.read(self._iprot)
3047 
    self._iprot.readMessageEnd()
3431 rajveer 3048 
    if result.success is not None:
2616 chandransh 3049 
      return result.success
3431 rajveer 3050 
    if result.ex is not None:
2616 chandransh 3051 
      raise result.ex
3052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3053 
 
2690 chandransh 3054 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3055 
    """
3056 
    Get all return orders created between the from and to dates for the given warehouse.
3057 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3058 
 
2690 chandransh 3059 
    Parameters:
3060 
     - warehouseId
3061 
     - fromDate
3062 
     - toDate
3063 
    """
3064 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3065 
    return self.recv_getReturnOrders()
2616 chandransh 3066 
 
2690 chandransh 3067 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3068 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3069 
    args = getReturnOrders_args()
3070 
    args.warehouseId = warehouseId
3071 
    args.fromDate = fromDate
3072 
    args.toDate = toDate
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_getReturnOrders(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = getReturnOrders_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3431 rajveer 3087 
    if result.success is not None:
2690 chandransh 3088 
      return result.success
3089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3090 
 
2700 chandransh 3091 
  def getReturnOrder(self, id):
3092 
    """
3093 
    Returns the ReturnOrder corresponding to the given id.
3094 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3095 
 
2700 chandransh 3096 
    Parameters:
3097 
     - id
3098 
    """
3099 
    self.send_getReturnOrder(id)
3100 
    return self.recv_getReturnOrder()
3101 
 
3102 
  def send_getReturnOrder(self, id):
3103 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3104 
    args = getReturnOrder_args()
3105 
    args.id = id
3106 
    args.write(self._oprot)
3107 
    self._oprot.writeMessageEnd()
3108 
    self._oprot.trans.flush()
3109 
 
3110 
  def recv_getReturnOrder(self, ):
3111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3112 
    if mtype == TMessageType.EXCEPTION:
3113 
      x = TApplicationException()
3114 
      x.read(self._iprot)
3115 
      self._iprot.readMessageEnd()
3116 
      raise x
3117 
    result = getReturnOrder_result()
3118 
    result.read(self._iprot)
3119 
    self._iprot.readMessageEnd()
3431 rajveer 3120 
    if result.success is not None:
2700 chandransh 3121 
      return result.success
3431 rajveer 3122 
    if result.ex is not None:
2700 chandransh 3123 
      raise result.ex
3124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3125 
 
2690 chandransh 3126 
  def processReturn(self, returnOrderId):
3127 
    """
3128 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3129 
 
2690 chandransh 3130 
    Parameters:
3131 
     - returnOrderId
3132 
    """
3133 
    self.send_processReturn(returnOrderId)
3134 
    self.recv_processReturn()
3135 
 
3136 
  def send_processReturn(self, returnOrderId):
3137 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3138 
    args = processReturn_args()
3139 
    args.returnOrderId = returnOrderId
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_processReturn(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = processReturn_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
3431 rajveer 3154 
    if result.ex is not None:
2690 chandransh 3155 
      raise result.ex
3156 
    return
3157 
 
2819 chandransh 3158 
  def createPurchaseOrder(self, warehouseId):
3159 
    """
4586 mandeep.dh 3160 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3161 
    Returns the list of PO no. of the newly created purchase order.
3162 
    Returns null if no new purchase order had to be created.
3431 rajveer 3163 
 
2819 chandransh 3164 
    Parameters:
3165 
     - warehouseId
3166 
    """
3167 
    self.send_createPurchaseOrder(warehouseId)
3168 
    return self.recv_createPurchaseOrder()
2690 chandransh 3169 
 
2819 chandransh 3170 
  def send_createPurchaseOrder(self, warehouseId):
3171 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3172 
    args = createPurchaseOrder_args()
3173 
    args.warehouseId = warehouseId
3174 
    args.write(self._oprot)
3175 
    self._oprot.writeMessageEnd()
3176 
    self._oprot.trans.flush()
3177 
 
3178 
  def recv_createPurchaseOrder(self, ):
3179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3180 
    if mtype == TMessageType.EXCEPTION:
3181 
      x = TApplicationException()
3182 
      x.read(self._iprot)
3183 
      self._iprot.readMessageEnd()
3184 
      raise x
3185 
    result = createPurchaseOrder_result()
3186 
    result.read(self._iprot)
3187 
    self._iprot.readMessageEnd()
3431 rajveer 3188 
    if result.success is not None:
2819 chandransh 3189 
      return result.success
3431 rajveer 3190 
    if result.ex is not None:
2819 chandransh 3191 
      raise result.ex
3192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3193 
 
3451 chandransh 3194 
  def updateWeight(self, orderId, weight):
3195 
    """
3196 
    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 3197 
 
3451 chandransh 3198 
    Parameters:
3199 
     - orderId
3200 
     - weight
3201 
    """
3202 
    self.send_updateWeight(orderId, weight)
3203 
    return self.recv_updateWeight()
3204 
 
3205 
  def send_updateWeight(self, orderId, weight):
3206 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3207 
    args = updateWeight_args()
3208 
    args.orderId = orderId
3209 
    args.weight = weight
3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_updateWeight(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = updateWeight_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3224 
    if result.success is not None:
3225 
      return result.success
3226 
    if result.ex is not None:
3227 
      raise result.ex
3228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3229 
 
3469 chandransh 3230 
  def changeItem(self, orderId, itemId):
3231 
    """
3232 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3233 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3234 
 
3469 chandransh 3235 
    Parameters:
3236 
     - orderId
3237 
     - itemId
3238 
    """
3239 
    self.send_changeItem(orderId, itemId)
3240 
    return self.recv_changeItem()
3241 
 
3242 
  def send_changeItem(self, orderId, itemId):
3243 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3244 
    args = changeItem_args()
3245 
    args.orderId = orderId
3246 
    args.itemId = itemId
3247 
    args.write(self._oprot)
3248 
    self._oprot.writeMessageEnd()
3249 
    self._oprot.trans.flush()
3250 
 
3251 
  def recv_changeItem(self, ):
3252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3253 
    if mtype == TMessageType.EXCEPTION:
3254 
      x = TApplicationException()
3255 
      x.read(self._iprot)
3256 
      self._iprot.readMessageEnd()
3257 
      raise x
3258 
    result = changeItem_result()
3259 
    result.read(self._iprot)
3260 
    self._iprot.readMessageEnd()
3261 
    if result.success is not None:
3262 
      return result.success
3263 
    if result.ex is not None:
3264 
      raise result.ex
3265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3266 
 
3267 
  def shiftToWarehouse(self, orderId, warehouseId):
3268 
    """
3269 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3270 
 
3271 
    Parameters:
3272 
     - orderId
3273 
     - warehouseId
3274 
    """
3275 
    self.send_shiftToWarehouse(orderId, warehouseId)
3276 
    return self.recv_shiftToWarehouse()
3277 
 
3278 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3279 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3280 
    args = shiftToWarehouse_args()
3281 
    args.orderId = orderId
3282 
    args.warehouseId = warehouseId
3283 
    args.write(self._oprot)
3284 
    self._oprot.writeMessageEnd()
3285 
    self._oprot.trans.flush()
3286 
 
3287 
  def recv_shiftToWarehouse(self, ):
3288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3289 
    if mtype == TMessageType.EXCEPTION:
3290 
      x = TApplicationException()
3291 
      x.read(self._iprot)
3292 
      self._iprot.readMessageEnd()
3293 
      raise x
3294 
    result = shiftToWarehouse_result()
3295 
    result.read(self._iprot)
3296 
    self._iprot.readMessageEnd()
3297 
    if result.success is not None:
3298 
      return result.success
3299 
    if result.ex is not None:
3300 
      raise result.ex
3301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3302 
 
4647 rajveer 3303 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3304 
    """
3305 
    Adds the given delay reason to the given order.
3986 chandransh 3306 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3307 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3308 
 
3553 chandransh 3309 
    Parameters:
3310 
     - orderId
3311 
     - delayReason
3986 chandransh 3312 
     - furtherDelay
4647 rajveer 3313 
     - delayReasonText
3553 chandransh 3314 
    """
4647 rajveer 3315 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3316 
    return self.recv_addDelayReason()
3317 
 
4647 rajveer 3318 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3319 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3320 
    args = addDelayReason_args()
3321 
    args.orderId = orderId
3322 
    args.delayReason = delayReason
3986 chandransh 3323 
    args.furtherDelay = furtherDelay
4647 rajveer 3324 
    args.delayReasonText = delayReasonText
3553 chandransh 3325 
    args.write(self._oprot)
3326 
    self._oprot.writeMessageEnd()
3327 
    self._oprot.trans.flush()
3328 
 
3329 
  def recv_addDelayReason(self, ):
3330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3331 
    if mtype == TMessageType.EXCEPTION:
3332 
      x = TApplicationException()
3333 
      x.read(self._iprot)
3334 
      self._iprot.readMessageEnd()
3335 
      raise x
3336 
    result = addDelayReason_result()
3337 
    result.read(self._iprot)
3338 
    self._iprot.readMessageEnd()
3339 
    if result.success is not None:
3340 
      return result.success
3341 
    if result.ex is not None:
3342 
      raise result.ex
3343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3344 
 
3956 chandransh 3345 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3346 
    """
3347 
    Marks the COD orders with given AWB nos. as having been processed.
3348 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3349 
 
3956 chandransh 3350 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3351 
    1. There is no order corresponding to an AWB number.
3352 
    2. The captured amount for a payment exceeds the total payment.
3353 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3354 
 
3355 
    Parameters:
3356 
     - collectedAmountMap
3357 
     - xferBy
3358 
     - xferTxnId
3359 
     - xferDate
3360 
    """
3361 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3362 
    return self.recv_reconcileCodCollection()
3363 
 
3364 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3365 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3366 
    args = reconcileCodCollection_args()
3367 
    args.collectedAmountMap = collectedAmountMap
3368 
    args.xferBy = xferBy
3369 
    args.xferTxnId = xferTxnId
3370 
    args.xferDate = xferDate
3371 
    args.write(self._oprot)
3372 
    self._oprot.writeMessageEnd()
3373 
    self._oprot.trans.flush()
3374 
 
3375 
  def recv_reconcileCodCollection(self, ):
3376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3377 
    if mtype == TMessageType.EXCEPTION:
3378 
      x = TApplicationException()
3379 
      x.read(self._iprot)
3380 
      self._iprot.readMessageEnd()
3381 
      raise x
3382 
    result = reconcileCodCollection_result()
3383 
    result.read(self._iprot)
3384 
    self._iprot.readMessageEnd()
3385 
    if result.success is not None:
3386 
      return result.success
3387 
    if result.ex is not None:
3388 
      raise result.ex
3389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3390 
 
4008 mandeep.dh 3391 
  def getTransactionsRequiringExtraProcessing(self, category):
3392 
    """
4065 mandeep.dh 3393 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3394 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3395 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3396 
 
4008 mandeep.dh 3397 
    Parameters:
3398 
     - category
3399 
    """
3400 
    self.send_getTransactionsRequiringExtraProcessing(category)
3401 
    return self.recv_getTransactionsRequiringExtraProcessing()
3402 
 
3403 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3404 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3405 
    args = getTransactionsRequiringExtraProcessing_args()
3406 
    args.category = category
3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = getTransactionsRequiringExtraProcessing_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3421 
    if result.success is not None:
3422 
      return result.success
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3424 
 
3425 
  def markTransactionAsProcessed(self, transactionId, category):
3426 
    """
3427 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3428 
    It essentially deletes the transaction id record for a particular
3429 
    processing type category (if present) from DB.
3430 
    This is currently used by CRM application.
4008 mandeep.dh 3431 
 
3432 
    Parameters:
3433 
     - transactionId
3434 
     - category
3435 
    """
3436 
    self.send_markTransactionAsProcessed(transactionId, category)
3437 
    self.recv_markTransactionAsProcessed()
3438 
 
3439 
  def send_markTransactionAsProcessed(self, transactionId, category):
3440 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3441 
    args = markTransactionAsProcessed_args()
3442 
    args.transactionId = transactionId
3443 
    args.category = category
3444 
    args.write(self._oprot)
3445 
    self._oprot.writeMessageEnd()
3446 
    self._oprot.trans.flush()
3447 
 
3448 
  def recv_markTransactionAsProcessed(self, ):
3449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3450 
    if mtype == TMessageType.EXCEPTION:
3451 
      x = TApplicationException()
3452 
      x.read(self._iprot)
3453 
      self._iprot.readMessageEnd()
3454 
      raise x
3455 
    result = markTransactionAsProcessed_result()
3456 
    result.read(self._iprot)
3457 
    self._iprot.readMessageEnd()
3458 
    return
3459 
 
4018 chandransh 3460 
  def getItemWiseRiskyOrdersCount(self, ):
3461 
    """
3462 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3463 
    is defined as one whose shipping date is about to expire.
3464 
    """
3465 
    self.send_getItemWiseRiskyOrdersCount()
3466 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3467 
 
4018 chandransh 3468 
  def send_getItemWiseRiskyOrdersCount(self, ):
3469 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3470 
    args = getItemWiseRiskyOrdersCount_args()
3471 
    args.write(self._oprot)
3472 
    self._oprot.writeMessageEnd()
3473 
    self._oprot.trans.flush()
3474 
 
3475 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3477 
    if mtype == TMessageType.EXCEPTION:
3478 
      x = TApplicationException()
3479 
      x.read(self._iprot)
3480 
      self._iprot.readMessageEnd()
3481 
      raise x
3482 
    result = getItemWiseRiskyOrdersCount_result()
3483 
    result.read(self._iprot)
3484 
    self._iprot.readMessageEnd()
3485 
    if result.success is not None:
3486 
      return result.success
3487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3488 
 
4295 varun.gupt 3489 
  def getOrdersForItemIds(self, itemIds):
3490 
    """
3491 
    Returns a list of all orders which have items with given id
3492 
 
3493 
    Parameters:
3494 
     - itemIds
3495 
    """
3496 
    self.send_getOrdersForItemIds(itemIds)
3497 
    return self.recv_getOrdersForItemIds()
3498 
 
3499 
  def send_getOrdersForItemIds(self, itemIds):
3500 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3501 
    args = getOrdersForItemIds_args()
3502 
    args.itemIds = itemIds
3503 
    args.write(self._oprot)
3504 
    self._oprot.writeMessageEnd()
3505 
    self._oprot.trans.flush()
3506 
 
3507 
  def recv_getOrdersForItemIds(self, ):
3508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3509 
    if mtype == TMessageType.EXCEPTION:
3510 
      x = TApplicationException()
3511 
      x.read(self._iprot)
3512 
      self._iprot.readMessageEnd()
3513 
      raise x
3514 
    result = getOrdersForItemIds_result()
3515 
    result.read(self._iprot)
3516 
    self._iprot.readMessageEnd()
3517 
    if result.success is not None:
3518 
      return result.success
3519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3520 
 
4247 rajveer 3521 
  def markOrderCancellationRequestReceived(self, orderId):
3522 
    """
3523 
    Mark order as cancellation request received. If customer sends request of cancellation of
3524 
    a particular order, this method will be called. It will just change status of the order
3525 
    depending on its current status. It also records the previous status, so that we can move
3526 
    back to that status if cancellation request is denied.
4018 chandransh 3527 
 
4247 rajveer 3528 
    Parameters:
3529 
     - orderId
3530 
    """
3531 
    self.send_markOrderCancellationRequestReceived(orderId)
3532 
    self.recv_markOrderCancellationRequestReceived()
3533 
 
3534 
  def send_markOrderCancellationRequestReceived(self, orderId):
3535 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3536 
    args = markOrderCancellationRequestReceived_args()
3537 
    args.orderId = orderId
3538 
    args.write(self._oprot)
3539 
    self._oprot.writeMessageEnd()
3540 
    self._oprot.trans.flush()
3541 
 
3542 
  def recv_markOrderCancellationRequestReceived(self, ):
3543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3544 
    if mtype == TMessageType.EXCEPTION:
3545 
      x = TApplicationException()
3546 
      x.read(self._iprot)
3547 
      self._iprot.readMessageEnd()
3548 
      raise x
3549 
    result = markOrderCancellationRequestReceived_result()
3550 
    result.read(self._iprot)
3551 
    self._iprot.readMessageEnd()
3552 
    if result.ex is not None:
3553 
      raise result.ex
3554 
    return
3555 
 
3556 
  def markOrderCancellationRequestConfirmed(self, orderId):
3557 
    """
3558 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3559 
    cancellation request confirmed. After this OM will be able to cancel the order.
3560 
 
3561 
    Parameters:
3562 
     - orderId
3563 
    """
3564 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3565 
    self.recv_markOrderCancellationRequestConfirmed()
3566 
 
3567 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3568 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3569 
    args = markOrderCancellationRequestConfirmed_args()
3570 
    args.orderId = orderId
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = markOrderCancellationRequestConfirmed_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3585 
    if result.ex is not None:
3586 
      raise result.ex
3587 
    return
3588 
 
3589 
  def markOrderCancellationRequestDenied(self, orderId):
3590 
    """
3591 
    If we decide to not to cancel order, we will move the order ro previous status.
3592 
 
3593 
    Parameters:
3594 
     - orderId
3595 
    """
3596 
    self.send_markOrderCancellationRequestDenied(orderId)
3597 
    self.recv_markOrderCancellationRequestDenied()
3598 
 
3599 
  def send_markOrderCancellationRequestDenied(self, orderId):
3600 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3601 
    args = markOrderCancellationRequestDenied_args()
3602 
    args.orderId = orderId
3603 
    args.write(self._oprot)
3604 
    self._oprot.writeMessageEnd()
3605 
    self._oprot.trans.flush()
3606 
 
3607 
  def recv_markOrderCancellationRequestDenied(self, ):
3608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3609 
    if mtype == TMessageType.EXCEPTION:
3610 
      x = TApplicationException()
3611 
      x.read(self._iprot)
3612 
      self._iprot.readMessageEnd()
3613 
      raise x
3614 
    result = markOrderCancellationRequestDenied_result()
3615 
    result.read(self._iprot)
3616 
    self._iprot.readMessageEnd()
3617 
    if result.ex is not None:
3618 
      raise result.ex
3619 
    return
3620 
 
4258 rajveer 3621 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3622 
    """
4258 rajveer 3623 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3624 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3625 
 
3626 
    Parameters:
4258 rajveer 3627 
     - transactionId
4247 rajveer 3628 
    """
4258 rajveer 3629 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3630 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3631 
 
4258 rajveer 3632 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3633 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3634 
    args = markTransactionAsPaymentFlagRemoved_args()
3635 
    args.transactionId = transactionId
4247 rajveer 3636 
    args.write(self._oprot)
3637 
    self._oprot.writeMessageEnd()
3638 
    self._oprot.trans.flush()
3639 
 
4258 rajveer 3640 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3642 
    if mtype == TMessageType.EXCEPTION:
3643 
      x = TApplicationException()
3644 
      x.read(self._iprot)
3645 
      self._iprot.readMessageEnd()
3646 
      raise x
4258 rajveer 3647 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3648 
    result.read(self._iprot)
3649 
    self._iprot.readMessageEnd()
3650 
    if result.ex is not None:
3651 
      raise result.ex
3652 
    return
3653 
 
4259 anupam.sin 3654 
  def refundTransaction(self, transactionId, refundedBy, reason):
3655 
    """
3656 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3657 
    need to be cancelled
4247 rajveer 3658 
 
4259 anupam.sin 3659 
    Parameters:
3660 
     - transactionId
3661 
     - refundedBy
3662 
     - reason
3663 
    """
3664 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3665 
    self.recv_refundTransaction()
3666 
 
3667 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3668 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3669 
    args = refundTransaction_args()
3670 
    args.transactionId = transactionId
3671 
    args.refundedBy = refundedBy
3672 
    args.reason = reason
3673 
    args.write(self._oprot)
3674 
    self._oprot.writeMessageEnd()
3675 
    self._oprot.trans.flush()
3676 
 
3677 
  def recv_refundTransaction(self, ):
3678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3679 
    if mtype == TMessageType.EXCEPTION:
3680 
      x = TApplicationException()
3681 
      x.read(self._iprot)
3682 
      self._iprot.readMessageEnd()
3683 
      raise x
3684 
    result = refundTransaction_result()
3685 
    result.read(self._iprot)
3686 
    self._iprot.readMessageEnd()
3687 
    if result.ex is not None:
3688 
      raise result.ex
3689 
    return
3690 
 
4324 mandeep.dh 3691 
  def updateShipmentAddress(self, orderId, addressId):
3692 
    """
3693 
    Updates shipment address of an order. Delivery and shipping date estimates
3694 
    etc. are also updated here.
3695 
 
3696 
    Throws TransactionServiceException in case address change is not
3697 
    possible due to certain reasons such as new pincode in address is
3698 
    not serviceable etc.
3699 
 
3700 
    Parameters:
3701 
     - orderId
3702 
     - addressId
3703 
    """
3704 
    self.send_updateShipmentAddress(orderId, addressId)
3705 
    self.recv_updateShipmentAddress()
3706 
 
3707 
  def send_updateShipmentAddress(self, orderId, addressId):
3708 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3709 
    args = updateShipmentAddress_args()
3710 
    args.orderId = orderId
3711 
    args.addressId = addressId
3712 
    args.write(self._oprot)
3713 
    self._oprot.writeMessageEnd()
3714 
    self._oprot.trans.flush()
3715 
 
3716 
  def recv_updateShipmentAddress(self, ):
3717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3718 
    if mtype == TMessageType.EXCEPTION:
3719 
      x = TApplicationException()
3720 
      x.read(self._iprot)
3721 
      self._iprot.readMessageEnd()
3722 
      raise x
3723 
    result = updateShipmentAddress_result()
3724 
    result.read(self._iprot)
3725 
    self._iprot.readMessageEnd()
3726 
    if result.ex is not None:
3727 
      raise result.ex
3728 
    return
3729 
 
4285 rajveer 3730 
  def acceptOrdersForItemId(self, itemId, inventory):
3731 
    """
3732 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3733 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3734 
 
4285 rajveer 3735 
    Parameters:
3736 
     - itemId
3737 
     - inventory
3738 
    """
3739 
    self.send_acceptOrdersForItemId(itemId, inventory)
3740 
    return self.recv_acceptOrdersForItemId()
3741 
 
3742 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3743 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3744 
    args = acceptOrdersForItemId_args()
3745 
    args.itemId = itemId
3746 
    args.inventory = inventory
3747 
    args.write(self._oprot)
3748 
    self._oprot.writeMessageEnd()
3749 
    self._oprot.trans.flush()
3750 
 
3751 
  def recv_acceptOrdersForItemId(self, ):
3752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3753 
    if mtype == TMessageType.EXCEPTION:
3754 
      x = TApplicationException()
3755 
      x.read(self._iprot)
3756 
      self._iprot.readMessageEnd()
3757 
      raise x
3758 
    result = acceptOrdersForItemId_result()
3759 
    result.read(self._iprot)
3760 
    self._iprot.readMessageEnd()
3761 
    if result.success is not None:
3762 
      return result.success
3763 
    if result.ex is not None:
3764 
      raise result.ex
3765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3766 
 
4369 rajveer 3767 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3768 
    """
3769 
    Parameters:
3770 
     - vendorId
3771 
     - itemId
3772 
     - quantity
3773 
     - estimate
4369 rajveer 3774 
     - isReminder
4303 rajveer 3775 
    """
4369 rajveer 3776 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3777 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3778 
 
4369 rajveer 3779 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3780 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3781 
    args = markOrdersAsPORaised_args()
3782 
    args.vendorId = vendorId
3783 
    args.itemId = itemId
3784 
    args.quantity = quantity
3785 
    args.estimate = estimate
4369 rajveer 3786 
    args.isReminder = isReminder
4303 rajveer 3787 
    args.write(self._oprot)
3788 
    self._oprot.writeMessageEnd()
3789 
    self._oprot.trans.flush()
3790 
 
3791 
  def recv_markOrdersAsPORaised(self, ):
3792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3793 
    if mtype == TMessageType.EXCEPTION:
3794 
      x = TApplicationException()
3795 
      x.read(self._iprot)
3796 
      self._iprot.readMessageEnd()
3797 
      raise x
3798 
    result = markOrdersAsPORaised_result()
3799 
    result.read(self._iprot)
3800 
    self._iprot.readMessageEnd()
3801 
    if result.ex is not None:
3802 
      raise result.ex
3803 
    return
3804 
 
4369 rajveer 3805 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3806 
    """
3807 
    Parameters:
3808 
     - vendorId
3809 
     - itemId
3810 
     - quantity
3811 
     - estimate
4369 rajveer 3812 
     - isReminder
4303 rajveer 3813 
    """
4369 rajveer 3814 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3815 
    self.recv_markOrdersAsReversalInitiated()
3816 
 
4369 rajveer 3817 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3818 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3819 
    args = markOrdersAsReversalInitiated_args()
3820 
    args.vendorId = vendorId
3821 
    args.itemId = itemId
3822 
    args.quantity = quantity
3823 
    args.estimate = estimate
4369 rajveer 3824 
    args.isReminder = isReminder
4303 rajveer 3825 
    args.write(self._oprot)
3826 
    self._oprot.writeMessageEnd()
3827 
    self._oprot.trans.flush()
3828 
 
3829 
  def recv_markOrdersAsReversalInitiated(self, ):
3830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3831 
    if mtype == TMessageType.EXCEPTION:
3832 
      x = TApplicationException()
3833 
      x.read(self._iprot)
3834 
      self._iprot.readMessageEnd()
3835 
      raise x
3836 
    result = markOrdersAsReversalInitiated_result()
3837 
    result.read(self._iprot)
3838 
    self._iprot.readMessageEnd()
3839 
    if result.ex is not None:
3840 
      raise result.ex
3841 
    return
3842 
 
4369 rajveer 3843 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3844 
    """
3845 
    Parameters:
3846 
     - vendorId
3847 
     - itemId
3848 
     - quantity
3849 
     - estimate
4369 rajveer 3850 
     - isReminder
4303 rajveer 3851 
    """
4369 rajveer 3852 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3853 
    self.recv_markOrdersAsNotAvailabke()
3854 
 
4369 rajveer 3855 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3856 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3857 
    args = markOrdersAsNotAvailabke_args()
3858 
    args.vendorId = vendorId
3859 
    args.itemId = itemId
3860 
    args.quantity = quantity
3861 
    args.estimate = estimate
4369 rajveer 3862 
    args.isReminder = isReminder
4303 rajveer 3863 
    args.write(self._oprot)
3864 
    self._oprot.writeMessageEnd()
3865 
    self._oprot.trans.flush()
3866 
 
3867 
  def recv_markOrdersAsNotAvailabke(self, ):
3868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3869 
    if mtype == TMessageType.EXCEPTION:
3870 
      x = TApplicationException()
3871 
      x.read(self._iprot)
3872 
      self._iprot.readMessageEnd()
3873 
      raise x
3874 
    result = markOrdersAsNotAvailabke_result()
3875 
    result.read(self._iprot)
3876 
    self._iprot.readMessageEnd()
3877 
    if result.ex is not None:
3878 
      raise result.ex
3879 
    return
3880 
 
4369 rajveer 3881 
  def markOrdersAsTimeout(self, vendorId):
3882 
    """
3883 
    Parameters:
3884 
     - vendorId
3885 
    """
3886 
    self.send_markOrdersAsTimeout(vendorId)
3887 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3888 
 
4369 rajveer 3889 
  def send_markOrdersAsTimeout(self, vendorId):
3890 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3891 
    args = markOrdersAsTimeout_args()
3892 
    args.vendorId = vendorId
3893 
    args.write(self._oprot)
3894 
    self._oprot.writeMessageEnd()
3895 
    self._oprot.trans.flush()
3896 
 
3897 
  def recv_markOrdersAsTimeout(self, ):
3898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3899 
    if mtype == TMessageType.EXCEPTION:
3900 
      x = TApplicationException()
3901 
      x.read(self._iprot)
3902 
      self._iprot.readMessageEnd()
3903 
      raise x
3904 
    result = markOrdersAsTimeout_result()
3905 
    result.read(self._iprot)
3906 
    self._iprot.readMessageEnd()
3907 
    if result.success is not None:
3908 
      return result.success
3909 
    if result.ex is not None:
3910 
      raise result.ex
3911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3912 
 
4662 rajveer 3913 
  def markOrderAsLostInTransit(self, orderId):
3914 
    """
3915 
    Mark order as LOST_IN_TRANSIT
3916 
 
3917 
    Parameters:
3918 
     - orderId
3919 
    """
3920 
    self.send_markOrderAsLostInTransit(orderId)
3921 
    return self.recv_markOrderAsLostInTransit()
3922 
 
3923 
  def send_markOrderAsLostInTransit(self, orderId):
3924 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3925 
    args = markOrderAsLostInTransit_args()
3926 
    args.orderId = orderId
3927 
    args.write(self._oprot)
3928 
    self._oprot.writeMessageEnd()
3929 
    self._oprot.trans.flush()
3930 
 
3931 
  def recv_markOrderAsLostInTransit(self, ):
3932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3933 
    if mtype == TMessageType.EXCEPTION:
3934 
      x = TApplicationException()
3935 
      x.read(self._iprot)
3936 
      self._iprot.readMessageEnd()
3937 
      raise x
3938 
    result = markOrderAsLostInTransit_result()
3939 
    result.read(self._iprot)
3940 
    self._iprot.readMessageEnd()
3941 
    if result.success is not None:
3942 
      return result.success
3943 
    if result.ex is not None:
3944 
      raise result.ex
3945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3946 
 
4386 anupam.sin 3947 
  def getOrderForAwb(self, awb):
3948 
    """
3949 
    Returns the order corresponding to an AWB number
4369 rajveer 3950 
 
4386 anupam.sin 3951 
    Parameters:
3952 
     - awb
3953 
    """
3954 
    self.send_getOrderForAwb(awb)
3955 
    return self.recv_getOrderForAwb()
3956 
 
3957 
  def send_getOrderForAwb(self, awb):
3958 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3959 
    args = getOrderForAwb_args()
3960 
    args.awb = awb
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_getOrderForAwb(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = getOrderForAwb_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3975 
    if result.success is not None:
3976 
      return result.success
3977 
    if result.ex is not None:
3978 
      raise result.ex
3979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3980 
 
4506 phani.kuma 3981 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3982 
    """
3983 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3984 
 
4506 phani.kuma 3985 
    Parameters:
3986 
     - logistics_provider_id
3987 
     - order_status
3988 
    """
3989 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3990 
    return self.recv_getOrdersForProviderForStatus()
3991 
 
3992 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3993 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3994 
    args = getOrdersForProviderForStatus_args()
3995 
    args.logistics_provider_id = logistics_provider_id
3996 
    args.order_status = order_status
3997 
    args.write(self._oprot)
3998 
    self._oprot.writeMessageEnd()
3999 
    self._oprot.trans.flush()
4000 
 
4001 
  def recv_getOrdersForProviderForStatus(self, ):
4002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4003 
    if mtype == TMessageType.EXCEPTION:
4004 
      x = TApplicationException()
4005 
      x.read(self._iprot)
4006 
      self._iprot.readMessageEnd()
4007 
      raise x
4008 
    result = getOrdersForProviderForStatus_result()
4009 
    result.read(self._iprot)
4010 
    self._iprot.readMessageEnd()
4011 
    if result.success is not None:
4012 
      return result.success
4013 
    if result.ex is not None:
4014 
      raise result.ex
4015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4016 
 
4600 varun.gupt 4017 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4018 
    """
4019 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4020 
 
4600 varun.gupt 4021 
    Parameters:
4022 
     - vendorId
4023 
     - billingDateFrom
4024 
     - billingDateTo
4025 
    """
4026 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4027 
    return self.recv_getBilledOrdersForVendor()
4028 
 
4029 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4030 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4031 
    args = getBilledOrdersForVendor_args()
4032 
    args.vendorId = vendorId
4033 
    args.billingDateFrom = billingDateFrom
4034 
    args.billingDateTo = billingDateTo
4035 
    args.write(self._oprot)
4036 
    self._oprot.writeMessageEnd()
4037 
    self._oprot.trans.flush()
4038 
 
4039 
  def recv_getBilledOrdersForVendor(self, ):
4040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4041 
    if mtype == TMessageType.EXCEPTION:
4042 
      x = TApplicationException()
4043 
      x.read(self._iprot)
4044 
      self._iprot.readMessageEnd()
4045 
      raise x
4046 
    result = getBilledOrdersForVendor_result()
4047 
    result.read(self._iprot)
4048 
    self._iprot.readMessageEnd()
4049 
    if result.success is not None:
4050 
      return result.success
4051 
    if result.ex is not None:
4052 
      raise result.ex
4053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4054 
 
4607 rajveer 4055 
  def getSlippedSippingDateOrders(self, ):
4056 
    self.send_getSlippedSippingDateOrders()
4057 
    return self.recv_getSlippedSippingDateOrders()
4058 
 
4059 
  def send_getSlippedSippingDateOrders(self, ):
4060 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4061 
    args = getSlippedSippingDateOrders_args()
4062 
    args.write(self._oprot)
4063 
    self._oprot.writeMessageEnd()
4064 
    self._oprot.trans.flush()
4065 
 
4066 
  def recv_getSlippedSippingDateOrders(self, ):
4067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4068 
    if mtype == TMessageType.EXCEPTION:
4069 
      x = TApplicationException()
4070 
      x.read(self._iprot)
4071 
      self._iprot.readMessageEnd()
4072 
      raise x
4073 
    result = getSlippedSippingDateOrders_result()
4074 
    result.read(self._iprot)
4075 
    self._iprot.readMessageEnd()
4076 
    if result.success is not None:
4077 
      return result.success
4078 
    if result.ex is not None:
4079 
      raise result.ex
4080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4081 
 
4709 rajveer 4082 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4083 
    """
4084 
    Parameters:
4085 
     - cancelDateFrom
4086 
     - cancelDateTo
4087 
    """
4088 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4089 
    return self.recv_getCancelledOrders()
4090 
 
4091 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4092 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4093 
    args = getCancelledOrders_args()
4094 
    args.cancelDateFrom = cancelDateFrom
4095 
    args.cancelDateTo = cancelDateTo
4096 
    args.write(self._oprot)
4097 
    self._oprot.writeMessageEnd()
4098 
    self._oprot.trans.flush()
4099 
 
4100 
  def recv_getCancelledOrders(self, ):
4101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4102 
    if mtype == TMessageType.EXCEPTION:
4103 
      x = TApplicationException()
4104 
      x.read(self._iprot)
4105 
      self._iprot.readMessageEnd()
4106 
      raise x
4107 
    result = getCancelledOrders_result()
4108 
    result.read(self._iprot)
4109 
    self._iprot.readMessageEnd()
4110 
    if result.success is not None:
4111 
      return result.success
4112 
    if result.ex is not None:
4113 
      raise result.ex
4114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4115 
 
4600 varun.gupt 4116 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4117 
    """
4118 
    Parameters:
4119 
     - mapAWBAndAmount
4120 
    """
4121 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4122 
    self.recv_saveBluedartSettlements()
4123 
 
4124 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4125 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4126 
    args = saveBluedartSettlements_args()
4127 
    args.mapAWBAndAmount = mapAWBAndAmount
4128 
    args.write(self._oprot)
4129 
    self._oprot.writeMessageEnd()
4130 
    self._oprot.trans.flush()
4131 
 
4132 
  def recv_saveBluedartSettlements(self, ):
4133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4134 
    if mtype == TMessageType.EXCEPTION:
4135 
      x = TApplicationException()
4136 
      x.read(self._iprot)
4137 
      self._iprot.readMessageEnd()
4138 
      raise x
4139 
    result = saveBluedartSettlements_result()
4140 
    result.read(self._iprot)
4141 
    self._iprot.readMessageEnd()
4142 
    if result.ex is not None:
4143 
      raise result.ex
4144 
    return
4145 
 
4146 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4147 
    """
4148 
    Parameters:
4149 
     - settlementDate
4150 
     - paymentGatewayId
4151 
     - paymentId
4152 
     - serviceTax
4153 
     - otherCharges
4154 
     - netCollection
4155 
    """
4156 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4157 
    self.recv_savePaymentSettlements()
4158 
 
4159 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4160 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4161 
    args = savePaymentSettlements_args()
4162 
    args.settlementDate = settlementDate
4163 
    args.paymentGatewayId = paymentGatewayId
4164 
    args.paymentId = paymentId
4165 
    args.serviceTax = serviceTax
4166 
    args.otherCharges = otherCharges
4167 
    args.netCollection = netCollection
4168 
    args.write(self._oprot)
4169 
    self._oprot.writeMessageEnd()
4170 
    self._oprot.trans.flush()
4171 
 
4172 
  def recv_savePaymentSettlements(self, ):
4173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4174 
    if mtype == TMessageType.EXCEPTION:
4175 
      x = TApplicationException()
4176 
      x.read(self._iprot)
4177 
      self._iprot.readMessageEnd()
4178 
      raise x
4179 
    result = savePaymentSettlements_result()
4180 
    result.read(self._iprot)
4181 
    self._iprot.readMessageEnd()
4182 
    if result.ex is not None:
4183 
      raise result.ex
4184 
    return
4185 
 
4186 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4187 
    """
4188 
    Parameters:
4189 
     - settlementId
4190 
     - settlementDate
4191 
     - transactionDateFrom
4192 
     - transactionDateTo
4193 
     - amount
4194 
    """
4195 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4196 
    self.recv_saveEBSSettlementSummary()
4197 
 
4198 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4199 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4200 
    args = saveEBSSettlementSummary_args()
4201 
    args.settlementId = settlementId
4202 
    args.settlementDate = settlementDate
4203 
    args.transactionDateFrom = transactionDateFrom
4204 
    args.transactionDateTo = transactionDateTo
4205 
    args.amount = amount
4206 
    args.write(self._oprot)
4207 
    self._oprot.writeMessageEnd()
4208 
    self._oprot.trans.flush()
4209 
 
4210 
  def recv_saveEBSSettlementSummary(self, ):
4211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4212 
    if mtype == TMessageType.EXCEPTION:
4213 
      x = TApplicationException()
4214 
      x.read(self._iprot)
4215 
      self._iprot.readMessageEnd()
4216 
      raise x
4217 
    result = saveEBSSettlementSummary_result()
4218 
    result.read(self._iprot)
4219 
    self._iprot.readMessageEnd()
4220 
    if result.ex is not None:
4221 
      raise result.ex
4222 
    return
4223 
 
4224 
  def getSettlementForPaymentId(self, paymentId):
4225 
    """
4226 
    Parameters:
4227 
     - paymentId
4228 
    """
4229 
    self.send_getSettlementForPaymentId(paymentId)
4230 
    return self.recv_getSettlementForPaymentId()
4231 
 
4232 
  def send_getSettlementForPaymentId(self, paymentId):
4233 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4234 
    args = getSettlementForPaymentId_args()
4235 
    args.paymentId = paymentId
4236 
    args.write(self._oprot)
4237 
    self._oprot.writeMessageEnd()
4238 
    self._oprot.trans.flush()
4239 
 
4240 
  def recv_getSettlementForPaymentId(self, ):
4241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4242 
    if mtype == TMessageType.EXCEPTION:
4243 
      x = TApplicationException()
4244 
      x.read(self._iprot)
4245 
      self._iprot.readMessageEnd()
4246 
      raise x
4247 
    result = getSettlementForPaymentId_result()
4248 
    result.read(self._iprot)
4249 
    self._iprot.readMessageEnd()
4250 
    if result.success is not None:
4251 
      return result.success
4252 
    if result.ex is not None:
4253 
      raise result.ex
4254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4255 
 
4256 
  def getEBSSettlementSummaries(self, ):
4257 
    self.send_getEBSSettlementSummaries()
4258 
    return self.recv_getEBSSettlementSummaries()
4259 
 
4260 
  def send_getEBSSettlementSummaries(self, ):
4261 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4262 
    args = getEBSSettlementSummaries_args()
4263 
    args.write(self._oprot)
4264 
    self._oprot.writeMessageEnd()
4265 
    self._oprot.trans.flush()
4266 
 
4267 
  def recv_getEBSSettlementSummaries(self, ):
4268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4269 
    if mtype == TMessageType.EXCEPTION:
4270 
      x = TApplicationException()
4271 
      x.read(self._iprot)
4272 
      self._iprot.readMessageEnd()
4273 
      raise x
4274 
    result = getEBSSettlementSummaries_result()
4275 
    result.read(self._iprot)
4276 
    self._iprot.readMessageEnd()
4277 
    if result.success is not None:
4278 
      return result.success
4279 
    if result.ex is not None:
4280 
      raise result.ex
4281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4282 
 
4283 
  def markEBSSettlementUploaded(self, settlementId):
4284 
    """
4285 
    Parameters:
4286 
     - settlementId
4287 
    """
4288 
    self.send_markEBSSettlementUploaded(settlementId)
4289 
    self.recv_markEBSSettlementUploaded()
4290 
 
4291 
  def send_markEBSSettlementUploaded(self, settlementId):
4292 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4293 
    args = markEBSSettlementUploaded_args()
4294 
    args.settlementId = settlementId
4295 
    args.write(self._oprot)
4296 
    self._oprot.writeMessageEnd()
4297 
    self._oprot.trans.flush()
4298 
 
4299 
  def recv_markEBSSettlementUploaded(self, ):
4300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4301 
    if mtype == TMessageType.EXCEPTION:
4302 
      x = TApplicationException()
4303 
      x.read(self._iprot)
4304 
      self._iprot.readMessageEnd()
4305 
      raise x
4306 
    result = markEBSSettlementUploaded_result()
4307 
    result.read(self._iprot)
4308 
    self._iprot.readMessageEnd()
4309 
    if result.ex is not None:
4310 
      raise result.ex
4311 
    return
4312 
 
4313 
  def getEBSSettlementDate(self, settlementId):
4314 
    """
4315 
    Parameters:
4316 
     - settlementId
4317 
    """
4318 
    self.send_getEBSSettlementDate(settlementId)
4319 
    return self.recv_getEBSSettlementDate()
4320 
 
4321 
  def send_getEBSSettlementDate(self, settlementId):
4322 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4323 
    args = getEBSSettlementDate_args()
4324 
    args.settlementId = settlementId
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_getEBSSettlementDate(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = getEBSSettlementDate_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    if result.success is not None:
4340 
      return result.success
4341 
    if result.ex is not None:
4342 
      raise result.ex
4343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4344 
 
4715 varun.gupt 4345 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4346 
    """
4347 
    Parameters:
4348 
     - settlementDateFrom
4349 
     - settlementDateTo
4350 
     - isRefund
4351 
    """
4352 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4353 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4354 
 
4715 varun.gupt 4355 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4356 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4357 
    args = getSettlementsByDate_args()
4358 
    args.settlementDateFrom = settlementDateFrom
4359 
    args.settlementDateTo = settlementDateTo
4360 
    args.isRefund = isRefund
4361 
    args.write(self._oprot)
4362 
    self._oprot.writeMessageEnd()
4363 
    self._oprot.trans.flush()
4364 
 
4365 
  def recv_getSettlementsByDate(self, ):
4366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4367 
    if mtype == TMessageType.EXCEPTION:
4368 
      x = TApplicationException()
4369 
      x.read(self._iprot)
4370 
      self._iprot.readMessageEnd()
4371 
      raise x
4372 
    result = getSettlementsByDate_result()
4373 
    result.read(self._iprot)
4374 
    self._iprot.readMessageEnd()
4375 
    if result.success is not None:
4376 
      return result.success
4377 
    if result.ex is not None:
4378 
      raise result.ex
4379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4380 
 
4381 
  def getReshippedOrderIds(self, orderIds):
4382 
    """
4383 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4384 
 
4385 
    Parameters:
4386 
     - orderIds
4387 
    """
4388 
    self.send_getReshippedOrderIds(orderIds)
4389 
    return self.recv_getReshippedOrderIds()
4390 
 
4391 
  def send_getReshippedOrderIds(self, orderIds):
4392 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4393 
    args = getReshippedOrderIds_args()
4394 
    args.orderIds = orderIds
4395 
    args.write(self._oprot)
4396 
    self._oprot.writeMessageEnd()
4397 
    self._oprot.trans.flush()
4398 
 
4399 
  def recv_getReshippedOrderIds(self, ):
4400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4401 
    if mtype == TMessageType.EXCEPTION:
4402 
      x = TApplicationException()
4403 
      x.read(self._iprot)
4404 
      self._iprot.readMessageEnd()
4405 
      raise x
4406 
    result = getReshippedOrderIds_result()
4407 
    result.read(self._iprot)
4408 
    self._iprot.readMessageEnd()
4409 
    if result.success is not None:
4410 
      return result.success
4411 
    if result.ex is not None:
4412 
      raise result.ex
4413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4414 
 
4415 
 
3376 rajveer 4416 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4417 
  def __init__(self, handler):
3376 rajveer 4418 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4419 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4420 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4421 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4422 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4423 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4424 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4425 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4426 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4427 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4428 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4429 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4430 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4431 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4432 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4433 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4434 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4435 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4436 
    self._processMap["createOrder"] = Processor.process_createOrder
4437 
    self._processMap["getOrder"] = Processor.process_getOrder
4438 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4439 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4440 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4441 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4442 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4443 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4444 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4445 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4446 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4447 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4448 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4449 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4450 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4451 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4452 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4453 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4454 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4455 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4456 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4457 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4458 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4459 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4460 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4461 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4462 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4463 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4464 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4465 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4466 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4467 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4468 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4469 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4470 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4471 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4472 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4473 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4474 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4475 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4476 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4477 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4478 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4479 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4480 
    self._processMap["changeItem"] = Processor.process_changeItem
4481 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4482 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4483 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4484 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4485 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4486 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4487 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4488 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4489 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4490 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4491 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4492 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4493 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4494 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4495 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4496 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4497 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4498 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4499 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4500 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4501 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4502 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4503 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4504 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4505 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4506 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4507 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4508 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4509 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4510 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4511 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4512 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4513 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
94 ashish 4514 
 
4515 
  def process(self, iprot, oprot):
4516 
    (name, type, seqid) = iprot.readMessageBegin()
4517 
    if name not in self._processMap:
4518 
      iprot.skip(TType.STRUCT)
4519 
      iprot.readMessageEnd()
4520 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4521 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4522 
      x.write(oprot)
4523 
      oprot.writeMessageEnd()
4524 
      oprot.trans.flush()
4525 
      return
4526 
    else:
4527 
      self._processMap[name](self, seqid, iprot, oprot)
4528 
    return True
4529 
 
4530 
  def process_createTransaction(self, seqid, iprot, oprot):
4531 
    args = createTransaction_args()
4532 
    args.read(iprot)
4533 
    iprot.readMessageEnd()
4534 
    result = createTransaction_result()
4535 
    try:
132 ashish 4536 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4537 
    except TransactionServiceException, ex:
4538 
      result.ex = ex
4539 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4540 
    result.write(oprot)
4541 
    oprot.writeMessageEnd()
4542 
    oprot.trans.flush()
4543 
 
4544 
  def process_getTransaction(self, seqid, iprot, oprot):
4545 
    args = getTransaction_args()
4546 
    args.read(iprot)
4547 
    iprot.readMessageEnd()
4548 
    result = getTransaction_result()
4549 
    try:
4550 
      result.success = self._handler.getTransaction(args.id)
4551 
    except TransactionServiceException, ex:
4552 
      result.ex = ex
4553 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4554 
    result.write(oprot)
4555 
    oprot.writeMessageEnd()
4556 
    oprot.trans.flush()
4557 
 
4558 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4559 
    args = getTransactionsForCustomer_args()
4560 
    args.read(iprot)
4561 
    iprot.readMessageEnd()
4562 
    result = getTransactionsForCustomer_result()
4563 
    try:
4564 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4565 
    except TransactionServiceException, ex:
4566 
      result.ex = ex
4567 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4568 
    result.write(oprot)
4569 
    oprot.writeMessageEnd()
4570 
    oprot.trans.flush()
4571 
 
132 ashish 4572 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4573 
    args = getTransactionsForShoppingCartId_args()
4574 
    args.read(iprot)
4575 
    iprot.readMessageEnd()
4576 
    result = getTransactionsForShoppingCartId_result()
4577 
    try:
4578 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4579 
    except TransactionServiceException, ex:
4580 
      result.ex = ex
4581 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
94 ashish 4586 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4587 
    args = getTransactionStatus_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = getTransactionStatus_result()
4591 
    try:
4592 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4593 
    except TransactionServiceException, ex:
4594 
      result.ex = ex
4595 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
4599 
 
4600 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4601 
    args = changeTransactionStatus_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = changeTransactionStatus_result()
4605 
    try:
4606 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4607 
    except TransactionServiceException, ex:
4608 
      result.ex = ex
4609 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4610 
    result.write(oprot)
4611 
    oprot.writeMessageEnd()
4612 
    oprot.trans.flush()
4613 
 
1398 varun.gupt 4614 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4615 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4616 
    args.read(iprot)
4617 
    iprot.readMessageEnd()
1398 varun.gupt 4618 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4619 
    try:
1398 varun.gupt 4620 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4621 
    except TransactionServiceException, ex:
4622 
      result.ex = ex
1398 varun.gupt 4623 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4624 
    result.write(oprot)
4625 
    oprot.writeMessageEnd()
4626 
    oprot.trans.flush()
4627 
 
483 rajveer 4628 
  def process_getAllOrders(self, seqid, iprot, oprot):
4629 
    args = getAllOrders_args()
94 ashish 4630 
    args.read(iprot)
4631 
    iprot.readMessageEnd()
483 rajveer 4632 
    result = getAllOrders_result()
94 ashish 4633 
    try:
483 rajveer 4634 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4635 
    except TransactionServiceException, ex:
4636 
      result.ex = ex
483 rajveer 4637 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4638 
    result.write(oprot)
4639 
    oprot.writeMessageEnd()
4640 
    oprot.trans.flush()
4641 
 
4133 chandransh 4642 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4643 
    args = getOrdersInBatch_args()
4644 
    args.read(iprot)
4645 
    iprot.readMessageEnd()
4646 
    result = getOrdersInBatch_result()
4647 
    try:
4648 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4649 
    except TransactionServiceException, ex:
4650 
      result.ex = ex
4651 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4652 
    result.write(oprot)
4653 
    oprot.writeMessageEnd()
4654 
    oprot.trans.flush()
4655 
 
4656 
  def process_getOrderCount(self, seqid, iprot, oprot):
4657 
    args = getOrderCount_args()
4658 
    args.read(iprot)
4659 
    iprot.readMessageEnd()
4660 
    result = getOrderCount_result()
4661 
    try:
4662 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4663 
    except TransactionServiceException, ex:
4664 
      result.ex = ex
4665 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4666 
    result.write(oprot)
4667 
    oprot.writeMessageEnd()
4668 
    oprot.trans.flush()
4669 
 
999 varun.gupt 4670 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4671 
    args = getOrdersByBillingDate_args()
4672 
    args.read(iprot)
4673 
    iprot.readMessageEnd()
4674 
    result = getOrdersByBillingDate_result()
4675 
    try:
4676 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4677 
    except TransactionServiceException, ex:
4678 
      result.ex = ex
4679 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4680 
    result.write(oprot)
4681 
    oprot.writeMessageEnd()
4682 
    oprot.trans.flush()
4683 
 
3427 chandransh 4684 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4685 
    args = getOrdersByShippingDate_args()
4686 
    args.read(iprot)
4687 
    iprot.readMessageEnd()
4688 
    result = getOrdersByShippingDate_result()
4689 
    try:
3451 chandransh 4690 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4691 
    except TransactionServiceException, ex:
4692 
      result.ex = ex
4693 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
1382 varun.gupt 4698 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4699 
    args = getReturnableOrdersForCustomer_args()
4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4702 
    result = getReturnableOrdersForCustomer_result()
4703 
    try:
4704 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4705 
    except TransactionServiceException, ex:
4706 
      result.ex = ex
4707 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4708 
    result.write(oprot)
4709 
    oprot.writeMessageEnd()
4710 
    oprot.trans.flush()
4711 
 
4712 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4713 
    args = getCancellableOrdersForCustomer_args()
4714 
    args.read(iprot)
4715 
    iprot.readMessageEnd()
4716 
    result = getCancellableOrdersForCustomer_result()
4717 
    try:
4718 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4719 
    except TransactionServiceException, ex:
4720 
      result.ex = ex
4721 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4722 
    result.write(oprot)
4723 
    oprot.writeMessageEnd()
4724 
    oprot.trans.flush()
4725 
 
483 rajveer 4726 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4727 
    args = changeOrderStatus_args()
94 ashish 4728 
    args.read(iprot)
4729 
    iprot.readMessageEnd()
483 rajveer 4730 
    result = changeOrderStatus_result()
94 ashish 4731 
    try:
483 rajveer 4732 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4733 
    except TransactionServiceException, ex:
4734 
      result.ex = ex
483 rajveer 4735 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4736 
    result.write(oprot)
4737 
    oprot.writeMessageEnd()
4738 
    oprot.trans.flush()
4739 
 
483 rajveer 4740 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4741 
    args = getOrdersForTransaction_args()
94 ashish 4742 
    args.read(iprot)
4743 
    iprot.readMessageEnd()
483 rajveer 4744 
    result = getOrdersForTransaction_result()
94 ashish 4745 
    try:
1528 ankur.sing 4746 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4747 
    except TransactionServiceException, ex:
4748 
      result.ex = ex
483 rajveer 4749 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4750 
    result.write(oprot)
4751 
    oprot.writeMessageEnd()
4752 
    oprot.trans.flush()
4753 
 
483 rajveer 4754 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4755 
    args = getOrdersForCustomer_args()
94 ashish 4756 
    args.read(iprot)
4757 
    iprot.readMessageEnd()
483 rajveer 4758 
    result = getOrdersForCustomer_result()
94 ashish 4759 
    try:
3014 chandransh 4760 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4761 
    except TransactionServiceException, ex:
4762 
      result.ex = ex
483 rajveer 4763 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4764 
    result.write(oprot)
4765 
    oprot.writeMessageEnd()
4766 
    oprot.trans.flush()
4767 
 
483 rajveer 4768 
  def process_createOrder(self, seqid, iprot, oprot):
4769 
    args = createOrder_args()
94 ashish 4770 
    args.read(iprot)
4771 
    iprot.readMessageEnd()
483 rajveer 4772 
    result = createOrder_result()
94 ashish 4773 
    try:
483 rajveer 4774 
      result.success = self._handler.createOrder(args.order)
94 ashish 4775 
    except TransactionServiceException, ex:
4776 
      result.ex = ex
483 rajveer 4777 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4778 
    result.write(oprot)
4779 
    oprot.writeMessageEnd()
4780 
    oprot.trans.flush()
4781 
 
483 rajveer 4782 
  def process_getOrder(self, seqid, iprot, oprot):
4783 
    args = getOrder_args()
94 ashish 4784 
    args.read(iprot)
4785 
    iprot.readMessageEnd()
483 rajveer 4786 
    result = getOrder_result()
94 ashish 4787 
    try:
483 rajveer 4788 
      result.success = self._handler.getOrder(args.id)
94 ashish 4789 
    except TransactionServiceException, ex:
4790 
      result.ex = ex
483 rajveer 4791 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4792 
    result.write(oprot)
4793 
    oprot.writeMessageEnd()
4794 
    oprot.trans.flush()
4795 
 
483 rajveer 4796 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4797 
    args = getLineItemsForOrder_args()
94 ashish 4798 
    args.read(iprot)
4799 
    iprot.readMessageEnd()
483 rajveer 4800 
    result = getLineItemsForOrder_result()
94 ashish 4801 
    try:
483 rajveer 4802 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4803 
    except TransactionServiceException, ex:
4804 
      result.ex = ex
483 rajveer 4805 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4806 
    result.write(oprot)
4807 
    oprot.writeMessageEnd()
4808 
    oprot.trans.flush()
4809 
 
1528 ankur.sing 4810 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4811 
    args = getOrderForCustomer_args()
4812 
    args.read(iprot)
4813 
    iprot.readMessageEnd()
4814 
    result = getOrderForCustomer_result()
4815 
    try:
4816 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4817 
    except TransactionServiceException, ex:
4818 
      result.ex = ex
4819 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4820 
    result.write(oprot)
4821 
    oprot.writeMessageEnd()
4822 
    oprot.trans.flush()
4823 
 
3064 chandransh 4824 
  def process_getAlerts(self, seqid, iprot, oprot):
4825 
    args = getAlerts_args()
4826 
    args.read(iprot)
4827 
    iprot.readMessageEnd()
4828 
    result = getAlerts_result()
4444 rajveer 4829 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4830 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4831 
    result.write(oprot)
4832 
    oprot.writeMessageEnd()
4833 
    oprot.trans.flush()
4834 
 
4394 rajveer 4835 
  def process_addAlert(self, seqid, iprot, oprot):
4836 
    args = addAlert_args()
3064 chandransh 4837 
    args.read(iprot)
4838 
    iprot.readMessageEnd()
4394 rajveer 4839 
    result = addAlert_result()
4444 rajveer 4840 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4841 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
4845 
 
4444 rajveer 4846 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4847 
    args = markAlertsAsSeen_args()
4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
4850 
    result = markAlertsAsSeen_result()
4851 
    self._handler.markAlertsAsSeen(args.warehouseId)
4852 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4853 
    result.write(oprot)
4854 
    oprot.writeMessageEnd()
4855 
    oprot.trans.flush()
4856 
 
3064 chandransh 4857 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4858 
    args = getValidOrderCount_args()
4859 
    args.read(iprot)
4860 
    iprot.readMessageEnd()
4861 
    result = getValidOrderCount_result()
4862 
    result.success = self._handler.getValidOrderCount()
4863 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4864 
    result.write(oprot)
4865 
    oprot.writeMessageEnd()
4866 
    oprot.trans.flush()
4867 
 
4868 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4869 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4870 
    args.read(iprot)
4871 
    iprot.readMessageEnd()
4872 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4873 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4874 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4875 
    result.write(oprot)
4876 
    oprot.writeMessageEnd()
4877 
    oprot.trans.flush()
4878 
 
4879 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4880 
    args = getValidOrdersAmountRange_args()
4881 
    args.read(iprot)
4882 
    iprot.readMessageEnd()
4883 
    result = getValidOrdersAmountRange_result()
4884 
    result.success = self._handler.getValidOrdersAmountRange()
4885 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4886 
    result.write(oprot)
4887 
    oprot.writeMessageEnd()
4888 
    oprot.trans.flush()
4889 
 
4890 
  def process_getValidOrders(self, seqid, iprot, oprot):
4891 
    args = getValidOrders_args()
4892 
    args.read(iprot)
4893 
    iprot.readMessageEnd()
4894 
    result = getValidOrders_result()
4895 
    result.success = self._handler.getValidOrders(args.limit)
4896 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4897 
    result.write(oprot)
4898 
    oprot.writeMessageEnd()
4899 
    oprot.trans.flush()
4900 
 
1220 chandransh 4901 
  def process_batchOrders(self, seqid, iprot, oprot):
4902 
    args = batchOrders_args()
4903 
    args.read(iprot)
4904 
    iprot.readMessageEnd()
4905 
    result = batchOrders_result()
4906 
    try:
4907 
      result.success = self._handler.batchOrders(args.warehouseId)
4908 
    except TransactionServiceException, ex:
4909 
      result.ex = ex
4910 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4911 
    result.write(oprot)
4912 
    oprot.writeMessageEnd()
4913 
    oprot.trans.flush()
4914 
 
1208 chandransh 4915 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4916 
    args = markOrderAsOutOfStock_args()
4917 
    args.read(iprot)
4918 
    iprot.readMessageEnd()
4919 
    result = markOrderAsOutOfStock_result()
4920 
    try:
4921 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4922 
    except TransactionServiceException, ex:
4923 
      result.ex = ex
4924 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4925 
    result.write(oprot)
4926 
    oprot.writeMessageEnd()
4927 
    oprot.trans.flush()
4928 
 
3064 chandransh 4929 
  def process_verifyOrder(self, seqid, iprot, oprot):
4930 
    args = verifyOrder_args()
759 chandransh 4931 
    args.read(iprot)
4932 
    iprot.readMessageEnd()
3064 chandransh 4933 
    result = verifyOrder_result()
759 chandransh 4934 
    try:
3064 chandransh 4935 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4936 
    except TransactionServiceException, ex:
4937 
      result.ex = ex
3064 chandransh 4938 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
4942 
 
3064 chandransh 4943 
  def process_acceptOrder(self, seqid, iprot, oprot):
4944 
    args = acceptOrder_args()
1113 chandransh 4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
3064 chandransh 4947 
    result = acceptOrder_result()
1113 chandransh 4948 
    try:
3064 chandransh 4949 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4950 
    except TransactionServiceException, ex:
4951 
      result.ex = ex
3064 chandransh 4952 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4953 
    result.write(oprot)
4954 
    oprot.writeMessageEnd()
4955 
    oprot.trans.flush()
4956 
 
3064 chandransh 4957 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4958 
    args = addBillingDetails_args()
1135 chandransh 4959 
    args.read(iprot)
4960 
    iprot.readMessageEnd()
3064 chandransh 4961 
    result = addBillingDetails_result()
1135 chandransh 4962 
    try:
4658 mandeep.dh 4963 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4964 
    except TransactionServiceException, ex:
4965 
      result.ex = ex
3064 chandransh 4966 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4967 
    result.write(oprot)
4968 
    oprot.writeMessageEnd()
4969 
    oprot.trans.flush()
4970 
 
4579 rajveer 4971 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4972 
    args = addInvoiceNumber_args()
4973 
    args.read(iprot)
4974 
    iprot.readMessageEnd()
4975 
    result = addInvoiceNumber_result()
4976 
    try:
4977 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4978 
    except TransactionServiceException, ex:
4979 
      result.ex = ex
4980 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
4984 
 
3064 chandransh 4985 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4986 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
3064 chandransh 4989 
    result = markOrdersAsManifested_result()
4990 
    try:
4991 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4992 
    except TransactionServiceException, ex:
4993 
      result.ex = ex
4994 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4995 
    result.write(oprot)
4996 
    oprot.writeMessageEnd()
4997 
    oprot.trans.flush()
4998 
 
4410 rajveer 4999 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5000 
    args = markOrdersAsShippedFromWarehouse_args()
5001 
    args.read(iprot)
5002 
    iprot.readMessageEnd()
5003 
    result = markOrdersAsShippedFromWarehouse_result()
5004 
    try:
5005 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
5006 
    except TransactionServiceException, ex:
5007 
      result.ex = ex
5008 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5009 
    result.write(oprot)
5010 
    oprot.writeMessageEnd()
5011 
    oprot.trans.flush()
5012 
 
3064 chandransh 5013 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5014 
    args = markOrdersAsPickedUp_args()
304 ashish 5015 
    args.read(iprot)
5016 
    iprot.readMessageEnd()
3064 chandransh 5017 
    result = markOrdersAsPickedUp_result()
5018 
    try:
5019 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5020 
    except TransactionServiceException, ex:
5021 
      result.ex = ex
5022 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5023 
    result.write(oprot)
5024 
    oprot.writeMessageEnd()
5025 
    oprot.trans.flush()
94 ashish 5026 
 
3064 chandransh 5027 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5028 
    args = markOrdersAsDelivered_args()
304 ashish 5029 
    args.read(iprot)
5030 
    iprot.readMessageEnd()
3064 chandransh 5031 
    result = markOrdersAsDelivered_result()
5032 
    try:
5033 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5034 
    except TransactionServiceException, ex:
5035 
      result.ex = ex
5036 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5037 
    result.write(oprot)
5038 
    oprot.writeMessageEnd()
5039 
    oprot.trans.flush()
5040 
 
3064 chandransh 5041 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5042 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5043 
    args.read(iprot)
5044 
    iprot.readMessageEnd()
3064 chandransh 5045 
    result = markOrdersAsFailed_result()
5046 
    try:
5047 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5048 
    except TransactionServiceException, ex:
5049 
      result.ex = ex
5050 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5051 
    result.write(oprot)
5052 
    oprot.writeMessageEnd()
5053 
    oprot.trans.flush()
304 ashish 5054 
 
3064 chandransh 5055 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5056 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5057 
    args.read(iprot)
5058 
    iprot.readMessageEnd()
3064 chandransh 5059 
    result = updateNonDeliveryReason_result()
5060 
    try:
4581 phani.kuma 5061 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5062 
    except TransactionServiceException, ex:
5063 
      result.ex = ex
5064 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5065 
    result.write(oprot)
5066 
    oprot.writeMessageEnd()
5067 
    oprot.trans.flush()
1596 ankur.sing 5068 
 
3064 chandransh 5069 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5070 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5071 
    args.read(iprot)
5072 
    iprot.readMessageEnd()
3064 chandransh 5073 
    result = getUndeliveredOrders_result()
5074 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5075 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
5079 
 
2536 chandransh 5080 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5081 
    args = toggleDOAFlag_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = toggleDOAFlag_result()
5085 
    try:
5086 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5087 
    except TransactionServiceException, ex:
5088 
      result.ex = ex
5089 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5090 
    result.write(oprot)
5091 
    oprot.writeMessageEnd()
5092 
    oprot.trans.flush()
1886 ankur.sing 5093 
 
4712 rajveer 5094 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5095 
    args = markOrderAsDelivered_args()
5096 
    args.read(iprot)
5097 
    iprot.readMessageEnd()
5098 
    result = markOrderAsDelivered_result()
5099 
    try:
5100 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5101 
    except TransactionServiceException, ex:
5102 
      result.ex = ex
5103 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
5107 
 
4454 rajveer 5108 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5109 
    args = markOrderDoaRequestReceived_args()
5110 
    args.read(iprot)
5111 
    iprot.readMessageEnd()
5112 
    result = markOrderDoaRequestReceived_result()
5113 
    try:
5114 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5115 
    except TransactionServiceException, ex:
5116 
      result.ex = ex
5117 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
5121 
 
5122 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5123 
    args = markOrderDoaRequestAuthorized_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = markOrderDoaRequestAuthorized_result()
5127 
    try:
5128 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5129 
    except TransactionServiceException, ex:
5130 
      result.ex = ex
5131 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5132 
    result.write(oprot)
5133 
    oprot.writeMessageEnd()
5134 
    oprot.trans.flush()
5135 
 
4488 rajveer 5136 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5137 
    args = markOrderReturnRequestReceived_args()
5138 
    args.read(iprot)
5139 
    iprot.readMessageEnd()
5140 
    result = markOrderReturnRequestReceived_result()
5141 
    try:
5142 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5143 
    except TransactionServiceException, ex:
5144 
      result.ex = ex
5145 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5146 
    result.write(oprot)
5147 
    oprot.writeMessageEnd()
5148 
    oprot.trans.flush()
5149 
 
5150 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5151 
    args = markOrderReturnRequestAuthorized_args()
5152 
    args.read(iprot)
5153 
    iprot.readMessageEnd()
5154 
    result = markOrderReturnRequestAuthorized_result()
5155 
    try:
5156 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5157 
    except TransactionServiceException, ex:
5158 
      result.ex = ex
5159 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5160 
    result.write(oprot)
5161 
    oprot.writeMessageEnd()
5162 
    oprot.trans.flush()
5163 
 
2536 chandransh 5164 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5165 
    args = requestPickupNumber_args()
5166 
    args.read(iprot)
5167 
    iprot.readMessageEnd()
5168 
    result = requestPickupNumber_result()
5169 
    try:
4579 rajveer 5170 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5171 
    except TransactionServiceException, ex:
5172 
      result.ex = ex
5173 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5174 
    result.write(oprot)
5175 
    oprot.writeMessageEnd()
5176 
    oprot.trans.flush()
5177 
 
5178 
  def process_authorizePickup(self, seqid, iprot, oprot):
5179 
    args = authorizePickup_args()
5180 
    args.read(iprot)
5181 
    iprot.readMessageEnd()
5182 
    result = authorizePickup_result()
5183 
    try:
4602 rajveer 5184 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5185 
    except TransactionServiceException, ex:
5186 
      result.ex = ex
5187 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5188 
    result.write(oprot)
5189 
    oprot.writeMessageEnd()
5190 
    oprot.trans.flush()
5191 
 
2764 chandransh 5192 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5193 
    args = markDoasAsPickedUp_args()
5194 
    args.read(iprot)
5195 
    iprot.readMessageEnd()
5196 
    result = markDoasAsPickedUp_result()
5197 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5198 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5199 
    result.write(oprot)
5200 
    oprot.writeMessageEnd()
5201 
    oprot.trans.flush()
5202 
 
4741 phani.kuma 5203 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5204 
    args = markReturnOrdersAsPickedUp_args()
5205 
    args.read(iprot)
5206 
    iprot.readMessageEnd()
5207 
    result = markReturnOrdersAsPickedUp_result()
5208 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5209 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5210 
    result.write(oprot)
5211 
    oprot.writeMessageEnd()
5212 
    oprot.trans.flush()
5213 
 
2616 chandransh 5214 
  def process_receiveReturn(self, seqid, iprot, oprot):
5215 
    args = receiveReturn_args()
2591 chandransh 5216 
    args.read(iprot)
5217 
    iprot.readMessageEnd()
2616 chandransh 5218 
    result = receiveReturn_result()
2591 chandransh 5219 
    try:
4479 rajveer 5220 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5221 
    except TransactionServiceException, ex:
5222 
      result.ex = ex
2616 chandransh 5223 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5224 
    result.write(oprot)
5225 
    oprot.writeMessageEnd()
5226 
    oprot.trans.flush()
2536 chandransh 5227 
 
2591 chandransh 5228 
  def process_validateDoa(self, seqid, iprot, oprot):
5229 
    args = validateDoa_args()
5230 
    args.read(iprot)
5231 
    iprot.readMessageEnd()
5232 
    result = validateDoa_result()
5233 
    try:
5234 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5235 
    except TransactionServiceException, ex:
5236 
      result.ex = ex
5237 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
5241 
 
4495 rajveer 5242 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5243 
    args = validateReturnProduct_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = validateReturnProduct_result()
5247 
    try:
5248 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5249 
    except TransactionServiceException, ex:
5250 
      result.ex = ex
5251 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5252 
    result.write(oprot)
5253 
    oprot.writeMessageEnd()
5254 
    oprot.trans.flush()
5255 
 
2616 chandransh 5256 
  def process_reshipOrder(self, seqid, iprot, oprot):
5257 
    args = reshipOrder_args()
5258 
    args.read(iprot)
5259 
    iprot.readMessageEnd()
5260 
    result = reshipOrder_result()
5261 
    try:
5262 
      result.success = self._handler.reshipOrder(args.orderId)
5263 
    except TransactionServiceException, ex:
5264 
      result.ex = ex
5265 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
2591 chandransh 5269 
 
2616 chandransh 5270 
  def process_refundOrder(self, seqid, iprot, oprot):
5271 
    args = refundOrder_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = refundOrder_result()
5275 
    try:
3226 chandransh 5276 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5277 
    except TransactionServiceException, ex:
5278 
      result.ex = ex
5279 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5280 
    result.write(oprot)
5281 
    oprot.writeMessageEnd()
5282 
    oprot.trans.flush()
5283 
 
2690 chandransh 5284 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5285 
    args = getReturnOrders_args()
5286 
    args.read(iprot)
5287 
    iprot.readMessageEnd()
5288 
    result = getReturnOrders_result()
5289 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5290 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5291 
    result.write(oprot)
5292 
    oprot.writeMessageEnd()
5293 
    oprot.trans.flush()
2616 chandransh 5294 
 
2700 chandransh 5295 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5296 
    args = getReturnOrder_args()
5297 
    args.read(iprot)
5298 
    iprot.readMessageEnd()
5299 
    result = getReturnOrder_result()
5300 
    try:
5301 
      result.success = self._handler.getReturnOrder(args.id)
5302 
    except TransactionServiceException, ex:
5303 
      result.ex = ex
5304 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5305 
    result.write(oprot)
5306 
    oprot.writeMessageEnd()
5307 
    oprot.trans.flush()
5308 
 
2690 chandransh 5309 
  def process_processReturn(self, seqid, iprot, oprot):
5310 
    args = processReturn_args()
5311 
    args.read(iprot)
5312 
    iprot.readMessageEnd()
5313 
    result = processReturn_result()
5314 
    try:
5315 
      self._handler.processReturn(args.returnOrderId)
5316 
    except TransactionServiceException, ex:
5317 
      result.ex = ex
5318 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5319 
    result.write(oprot)
5320 
    oprot.writeMessageEnd()
5321 
    oprot.trans.flush()
5322 
 
2819 chandransh 5323 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5324 
    args = createPurchaseOrder_args()
5325 
    args.read(iprot)
5326 
    iprot.readMessageEnd()
5327 
    result = createPurchaseOrder_result()
5328 
    try:
5329 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5330 
    except TransactionServiceException, ex:
5331 
      result.ex = ex
5332 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5333 
    result.write(oprot)
5334 
    oprot.writeMessageEnd()
5335 
    oprot.trans.flush()
2690 chandransh 5336 
 
3451 chandransh 5337 
  def process_updateWeight(self, seqid, iprot, oprot):
5338 
    args = updateWeight_args()
5339 
    args.read(iprot)
5340 
    iprot.readMessageEnd()
5341 
    result = updateWeight_result()
5342 
    try:
5343 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5344 
    except TransactionServiceException, ex:
5345 
      result.ex = ex
5346 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5347 
    result.write(oprot)
5348 
    oprot.writeMessageEnd()
5349 
    oprot.trans.flush()
2819 chandransh 5350 
 
3469 chandransh 5351 
  def process_changeItem(self, seqid, iprot, oprot):
5352 
    args = changeItem_args()
5353 
    args.read(iprot)
5354 
    iprot.readMessageEnd()
5355 
    result = changeItem_result()
5356 
    try:
5357 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5358 
    except TransactionServiceException, ex:
5359 
      result.ex = ex
5360 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5361 
    result.write(oprot)
5362 
    oprot.writeMessageEnd()
5363 
    oprot.trans.flush()
3451 chandransh 5364 
 
3469 chandransh 5365 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5366 
    args = shiftToWarehouse_args()
5367 
    args.read(iprot)
5368 
    iprot.readMessageEnd()
5369 
    result = shiftToWarehouse_result()
5370 
    try:
5371 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5372 
    except TransactionServiceException, ex:
5373 
      result.ex = ex
5374 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5375 
    result.write(oprot)
5376 
    oprot.writeMessageEnd()
5377 
    oprot.trans.flush()
5378 
 
3553 chandransh 5379 
  def process_addDelayReason(self, seqid, iprot, oprot):
5380 
    args = addDelayReason_args()
5381 
    args.read(iprot)
5382 
    iprot.readMessageEnd()
5383 
    result = addDelayReason_result()
5384 
    try:
4647 rajveer 5385 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5386 
    except TransactionServiceException, ex:
5387 
      result.ex = ex
5388 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5389 
    result.write(oprot)
5390 
    oprot.writeMessageEnd()
5391 
    oprot.trans.flush()
3469 chandransh 5392 
 
3956 chandransh 5393 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5394 
    args = reconcileCodCollection_args()
5395 
    args.read(iprot)
5396 
    iprot.readMessageEnd()
5397 
    result = reconcileCodCollection_result()
5398 
    try:
5399 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5400 
    except TransactionServiceException, ex:
5401 
      result.ex = ex
5402 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5403 
    result.write(oprot)
5404 
    oprot.writeMessageEnd()
5405 
    oprot.trans.flush()
3553 chandransh 5406 
 
4008 mandeep.dh 5407 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5408 
    args = getTransactionsRequiringExtraProcessing_args()
5409 
    args.read(iprot)
5410 
    iprot.readMessageEnd()
5411 
    result = getTransactionsRequiringExtraProcessing_result()
5412 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5413 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5414 
    result.write(oprot)
5415 
    oprot.writeMessageEnd()
5416 
    oprot.trans.flush()
3956 chandransh 5417 
 
4008 mandeep.dh 5418 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5419 
    args = markTransactionAsProcessed_args()
5420 
    args.read(iprot)
5421 
    iprot.readMessageEnd()
5422 
    result = markTransactionAsProcessed_result()
5423 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5424 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5425 
    result.write(oprot)
5426 
    oprot.writeMessageEnd()
5427 
    oprot.trans.flush()
5428 
 
4018 chandransh 5429 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5430 
    args = getItemWiseRiskyOrdersCount_args()
5431 
    args.read(iprot)
5432 
    iprot.readMessageEnd()
5433 
    result = getItemWiseRiskyOrdersCount_result()
5434 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5435 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5436 
    result.write(oprot)
5437 
    oprot.writeMessageEnd()
5438 
    oprot.trans.flush()
4008 mandeep.dh 5439 
 
4295 varun.gupt 5440 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5441 
    args = getOrdersForItemIds_args()
5442 
    args.read(iprot)
5443 
    iprot.readMessageEnd()
5444 
    result = getOrdersForItemIds_result()
5445 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5446 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5447 
    result.write(oprot)
5448 
    oprot.writeMessageEnd()
5449 
    oprot.trans.flush()
5450 
 
4247 rajveer 5451 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5452 
    args = markOrderCancellationRequestReceived_args()
5453 
    args.read(iprot)
5454 
    iprot.readMessageEnd()
5455 
    result = markOrderCancellationRequestReceived_result()
5456 
    try:
5457 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5458 
    except TransactionServiceException, ex:
5459 
      result.ex = ex
5460 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5461 
    result.write(oprot)
5462 
    oprot.writeMessageEnd()
5463 
    oprot.trans.flush()
4018 chandransh 5464 
 
4247 rajveer 5465 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5466 
    args = markOrderCancellationRequestConfirmed_args()
5467 
    args.read(iprot)
5468 
    iprot.readMessageEnd()
5469 
    result = markOrderCancellationRequestConfirmed_result()
5470 
    try:
5471 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5472 
    except TransactionServiceException, ex:
5473 
      result.ex = ex
5474 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5475 
    result.write(oprot)
5476 
    oprot.writeMessageEnd()
5477 
    oprot.trans.flush()
5478 
 
5479 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5480 
    args = markOrderCancellationRequestDenied_args()
5481 
    args.read(iprot)
5482 
    iprot.readMessageEnd()
5483 
    result = markOrderCancellationRequestDenied_result()
5484 
    try:
5485 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5486 
    except TransactionServiceException, ex:
5487 
      result.ex = ex
5488 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5489 
    result.write(oprot)
5490 
    oprot.writeMessageEnd()
5491 
    oprot.trans.flush()
5492 
 
4258 rajveer 5493 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5494 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5495 
    args.read(iprot)
5496 
    iprot.readMessageEnd()
4258 rajveer 5497 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5498 
    try:
4258 rajveer 5499 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5500 
    except TransactionServiceException, ex:
5501 
      result.ex = ex
4258 rajveer 5502 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5503 
    result.write(oprot)
5504 
    oprot.writeMessageEnd()
5505 
    oprot.trans.flush()
5506 
 
4259 anupam.sin 5507 
  def process_refundTransaction(self, seqid, iprot, oprot):
5508 
    args = refundTransaction_args()
5509 
    args.read(iprot)
5510 
    iprot.readMessageEnd()
5511 
    result = refundTransaction_result()
5512 
    try:
5513 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5514 
    except TransactionServiceException, ex:
5515 
      result.ex = ex
5516 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5517 
    result.write(oprot)
5518 
    oprot.writeMessageEnd()
5519 
    oprot.trans.flush()
4247 rajveer 5520 
 
4324 mandeep.dh 5521 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5522 
    args = updateShipmentAddress_args()
5523 
    args.read(iprot)
5524 
    iprot.readMessageEnd()
5525 
    result = updateShipmentAddress_result()
5526 
    try:
5527 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5528 
    except TransactionServiceException, ex:
5529 
      result.ex = ex
5530 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5531 
    result.write(oprot)
5532 
    oprot.writeMessageEnd()
5533 
    oprot.trans.flush()
5534 
 
4285 rajveer 5535 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5536 
    args = acceptOrdersForItemId_args()
5537 
    args.read(iprot)
5538 
    iprot.readMessageEnd()
5539 
    result = acceptOrdersForItemId_result()
5540 
    try:
5541 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5542 
    except TransactionServiceException, ex:
5543 
      result.ex = ex
5544 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5545 
    result.write(oprot)
5546 
    oprot.writeMessageEnd()
5547 
    oprot.trans.flush()
4259 anupam.sin 5548 
 
4303 rajveer 5549 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5550 
    args = markOrdersAsPORaised_args()
5551 
    args.read(iprot)
5552 
    iprot.readMessageEnd()
5553 
    result = markOrdersAsPORaised_result()
5554 
    try:
4369 rajveer 5555 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5556 
    except TransactionServiceException, ex:
5557 
      result.ex = ex
5558 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5559 
    result.write(oprot)
5560 
    oprot.writeMessageEnd()
5561 
    oprot.trans.flush()
4285 rajveer 5562 
 
4303 rajveer 5563 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5564 
    args = markOrdersAsReversalInitiated_args()
5565 
    args.read(iprot)
5566 
    iprot.readMessageEnd()
5567 
    result = markOrdersAsReversalInitiated_result()
5568 
    try:
4369 rajveer 5569 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5570 
    except TransactionServiceException, ex:
5571 
      result.ex = ex
5572 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5573 
    result.write(oprot)
5574 
    oprot.writeMessageEnd()
5575 
    oprot.trans.flush()
5576 
 
5577 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5578 
    args = markOrdersAsNotAvailabke_args()
5579 
    args.read(iprot)
5580 
    iprot.readMessageEnd()
5581 
    result = markOrdersAsNotAvailabke_result()
5582 
    try:
4369 rajveer 5583 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5584 
    except TransactionServiceException, ex:
5585 
      result.ex = ex
5586 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5587 
    result.write(oprot)
5588 
    oprot.writeMessageEnd()
5589 
    oprot.trans.flush()
5590 
 
4369 rajveer 5591 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5592 
    args = markOrdersAsTimeout_args()
5593 
    args.read(iprot)
5594 
    iprot.readMessageEnd()
5595 
    result = markOrdersAsTimeout_result()
5596 
    try:
5597 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5598 
    except TransactionServiceException, ex:
5599 
      result.ex = ex
5600 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5601 
    result.write(oprot)
5602 
    oprot.writeMessageEnd()
5603 
    oprot.trans.flush()
4303 rajveer 5604 
 
4662 rajveer 5605 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5606 
    args = markOrderAsLostInTransit_args()
5607 
    args.read(iprot)
5608 
    iprot.readMessageEnd()
5609 
    result = markOrderAsLostInTransit_result()
5610 
    try:
5611 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5612 
    except TransactionServiceException, ex:
5613 
      result.ex = ex
5614 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5615 
    result.write(oprot)
5616 
    oprot.writeMessageEnd()
5617 
    oprot.trans.flush()
5618 
 
4386 anupam.sin 5619 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5620 
    args = getOrderForAwb_args()
5621 
    args.read(iprot)
5622 
    iprot.readMessageEnd()
5623 
    result = getOrderForAwb_result()
5624 
    try:
5625 
      result.success = self._handler.getOrderForAwb(args.awb)
5626 
    except TransactionServiceException, ex:
5627 
      result.ex = ex
5628 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5629 
    result.write(oprot)
5630 
    oprot.writeMessageEnd()
5631 
    oprot.trans.flush()
4369 rajveer 5632 
 
4506 phani.kuma 5633 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5634 
    args = getOrdersForProviderForStatus_args()
5635 
    args.read(iprot)
5636 
    iprot.readMessageEnd()
5637 
    result = getOrdersForProviderForStatus_result()
5638 
    try:
5639 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5640 
    except TransactionServiceException, ex:
5641 
      result.ex = ex
5642 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5643 
    result.write(oprot)
5644 
    oprot.writeMessageEnd()
5645 
    oprot.trans.flush()
4386 anupam.sin 5646 
 
4600 varun.gupt 5647 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5648 
    args = getBilledOrdersForVendor_args()
5649 
    args.read(iprot)
5650 
    iprot.readMessageEnd()
5651 
    result = getBilledOrdersForVendor_result()
5652 
    try:
5653 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5654 
    except TransactionServiceException, ex:
5655 
      result.ex = ex
5656 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5657 
    result.write(oprot)
5658 
    oprot.writeMessageEnd()
5659 
    oprot.trans.flush()
4506 phani.kuma 5660 
 
4607 rajveer 5661 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5662 
    args = getSlippedSippingDateOrders_args()
5663 
    args.read(iprot)
5664 
    iprot.readMessageEnd()
5665 
    result = getSlippedSippingDateOrders_result()
5666 
    try:
5667 
      result.success = self._handler.getSlippedSippingDateOrders()
5668 
    except TransactionServiceException, ex:
5669 
      result.ex = ex
5670 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5671 
    result.write(oprot)
5672 
    oprot.writeMessageEnd()
5673 
    oprot.trans.flush()
5674 
 
4709 rajveer 5675 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5676 
    args = getCancelledOrders_args()
5677 
    args.read(iprot)
5678 
    iprot.readMessageEnd()
5679 
    result = getCancelledOrders_result()
5680 
    try:
5681 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5682 
    except TransactionServiceException, ex:
5683 
      result.ex = ex
5684 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5685 
    result.write(oprot)
5686 
    oprot.writeMessageEnd()
5687 
    oprot.trans.flush()
5688 
 
4600 varun.gupt 5689 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5690 
    args = saveBluedartSettlements_args()
5691 
    args.read(iprot)
5692 
    iprot.readMessageEnd()
5693 
    result = saveBluedartSettlements_result()
5694 
    try:
5695 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5696 
    except TransactionServiceException, ex:
5697 
      result.ex = ex
5698 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5699 
    result.write(oprot)
5700 
    oprot.writeMessageEnd()
5701 
    oprot.trans.flush()
5702 
 
5703 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5704 
    args = savePaymentSettlements_args()
5705 
    args.read(iprot)
5706 
    iprot.readMessageEnd()
5707 
    result = savePaymentSettlements_result()
5708 
    try:
5709 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5710 
    except TransactionServiceException, ex:
5711 
      result.ex = ex
5712 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5713 
    result.write(oprot)
5714 
    oprot.writeMessageEnd()
5715 
    oprot.trans.flush()
5716 
 
5717 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5718 
    args = saveEBSSettlementSummary_args()
5719 
    args.read(iprot)
5720 
    iprot.readMessageEnd()
5721 
    result = saveEBSSettlementSummary_result()
5722 
    try:
5723 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5724 
    except TransactionServiceException, ex:
5725 
      result.ex = ex
5726 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5727 
    result.write(oprot)
5728 
    oprot.writeMessageEnd()
5729 
    oprot.trans.flush()
5730 
 
5731 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5732 
    args = getSettlementForPaymentId_args()
5733 
    args.read(iprot)
5734 
    iprot.readMessageEnd()
5735 
    result = getSettlementForPaymentId_result()
5736 
    try:
5737 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5738 
    except TransactionServiceException, ex:
5739 
      result.ex = ex
5740 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5741 
    result.write(oprot)
5742 
    oprot.writeMessageEnd()
5743 
    oprot.trans.flush()
5744 
 
5745 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5746 
    args = getEBSSettlementSummaries_args()
5747 
    args.read(iprot)
5748 
    iprot.readMessageEnd()
5749 
    result = getEBSSettlementSummaries_result()
5750 
    try:
5751 
      result.success = self._handler.getEBSSettlementSummaries()
5752 
    except TransactionServiceException, ex:
5753 
      result.ex = ex
5754 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5755 
    result.write(oprot)
5756 
    oprot.writeMessageEnd()
5757 
    oprot.trans.flush()
5758 
 
5759 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5760 
    args = markEBSSettlementUploaded_args()
5761 
    args.read(iprot)
5762 
    iprot.readMessageEnd()
5763 
    result = markEBSSettlementUploaded_result()
5764 
    try:
5765 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5766 
    except TransactionServiceException, ex:
5767 
      result.ex = ex
5768 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5769 
    result.write(oprot)
5770 
    oprot.writeMessageEnd()
5771 
    oprot.trans.flush()
5772 
 
5773 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5774 
    args = getEBSSettlementDate_args()
5775 
    args.read(iprot)
5776 
    iprot.readMessageEnd()
5777 
    result = getEBSSettlementDate_result()
5778 
    try:
5779 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5780 
    except TransactionServiceException, ex:
5781 
      result.ex = ex
5782 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5783 
    result.write(oprot)
5784 
    oprot.writeMessageEnd()
5785 
    oprot.trans.flush()
5786 
 
4715 varun.gupt 5787 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5788 
    args = getSettlementsByDate_args()
5789 
    args.read(iprot)
5790 
    iprot.readMessageEnd()
5791 
    result = getSettlementsByDate_result()
5792 
    try:
5793 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5794 
    except TransactionServiceException, ex:
5795 
      result.ex = ex
5796 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5797 
    result.write(oprot)
5798 
    oprot.writeMessageEnd()
5799 
    oprot.trans.flush()
4600 varun.gupt 5800 
 
4715 varun.gupt 5801 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5802 
    args = getReshippedOrderIds_args()
5803 
    args.read(iprot)
5804 
    iprot.readMessageEnd()
5805 
    result = getReshippedOrderIds_result()
5806 
    try:
5807 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5808 
    except TransactionServiceException, ex:
5809 
      result.ex = ex
5810 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5811 
    result.write(oprot)
5812 
    oprot.writeMessageEnd()
5813 
    oprot.trans.flush()
5814 
 
5815 
 
94 ashish 5816 
# HELPER FUNCTIONS AND STRUCTURES
5817 
 
5818 
class createTransaction_args:
5819 
  """
5820 
  Attributes:
5821 
   - transaction
5822 
  """
5823 
 
5824 
  thrift_spec = (
5825 
    None, # 0
5826 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5827 
  )
5828 
 
5829 
  def __init__(self, transaction=None,):
5830 
    self.transaction = transaction
5831 
 
5832 
  def read(self, iprot):
5833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5835 
      return
5836 
    iprot.readStructBegin()
5837 
    while True:
5838 
      (fname, ftype, fid) = iprot.readFieldBegin()
5839 
      if ftype == TType.STOP:
5840 
        break
5841 
      if fid == 1:
5842 
        if ftype == TType.STRUCT:
5843 
          self.transaction = Transaction()
5844 
          self.transaction.read(iprot)
5845 
        else:
5846 
          iprot.skip(ftype)
5847 
      else:
5848 
        iprot.skip(ftype)
5849 
      iprot.readFieldEnd()
5850 
    iprot.readStructEnd()
5851 
 
5852 
  def write(self, oprot):
5853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5855 
      return
5856 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5857 
    if self.transaction is not None:
94 ashish 5858 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5859 
      self.transaction.write(oprot)
5860 
      oprot.writeFieldEnd()
5861 
    oprot.writeFieldStop()
5862 
    oprot.writeStructEnd()
5863 
 
3431 rajveer 5864 
  def validate(self):
5865 
    return
5866 
 
5867 
 
94 ashish 5868 
  def __repr__(self):
5869 
    L = ['%s=%r' % (key, value)
5870 
      for key, value in self.__dict__.iteritems()]
5871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5872 
 
5873 
  def __eq__(self, other):
5874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5875 
 
5876 
  def __ne__(self, other):
5877 
    return not (self == other)
5878 
 
5879 
class createTransaction_result:
5880 
  """
5881 
  Attributes:
132 ashish 5882 
   - success
94 ashish 5883 
   - ex
5884 
  """
5885 
 
5886 
  thrift_spec = (
132 ashish 5887 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5889 
  )
5890 
 
132 ashish 5891 
  def __init__(self, success=None, ex=None,):
5892 
    self.success = success
94 ashish 5893 
    self.ex = ex
5894 
 
5895 
  def read(self, iprot):
5896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5898 
      return
5899 
    iprot.readStructBegin()
5900 
    while True:
5901 
      (fname, ftype, fid) = iprot.readFieldBegin()
5902 
      if ftype == TType.STOP:
5903 
        break
132 ashish 5904 
      if fid == 0:
5905 
        if ftype == TType.I64:
5906 
          self.success = iprot.readI64();
5907 
        else:
5908 
          iprot.skip(ftype)
5909 
      elif fid == 1:
94 ashish 5910 
        if ftype == TType.STRUCT:
5911 
          self.ex = TransactionServiceException()
5912 
          self.ex.read(iprot)
5913 
        else:
5914 
          iprot.skip(ftype)
5915 
      else:
5916 
        iprot.skip(ftype)
5917 
      iprot.readFieldEnd()
5918 
    iprot.readStructEnd()
5919 
 
5920 
  def write(self, oprot):
5921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5923 
      return
5924 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5925 
    if self.success is not None:
132 ashish 5926 
      oprot.writeFieldBegin('success', TType.I64, 0)
5927 
      oprot.writeI64(self.success)
5928 
      oprot.writeFieldEnd()
3431 rajveer 5929 
    if self.ex is not None:
94 ashish 5930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5931 
      self.ex.write(oprot)
5932 
      oprot.writeFieldEnd()
5933 
    oprot.writeFieldStop()
5934 
    oprot.writeStructEnd()
5935 
 
3431 rajveer 5936 
  def validate(self):
5937 
    return
5938 
 
5939 
 
94 ashish 5940 
  def __repr__(self):
5941 
    L = ['%s=%r' % (key, value)
5942 
      for key, value in self.__dict__.iteritems()]
5943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5944 
 
5945 
  def __eq__(self, other):
5946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5947 
 
5948 
  def __ne__(self, other):
5949 
    return not (self == other)
5950 
 
5951 
class getTransaction_args:
5952 
  """
5953 
  Attributes:
5954 
   - id
5955 
  """
5956 
 
5957 
  thrift_spec = (
5958 
    None, # 0
5959 
    (1, TType.I64, 'id', None, None, ), # 1
5960 
  )
5961 
 
5962 
  def __init__(self, id=None,):
5963 
    self.id = id
5964 
 
5965 
  def read(self, iprot):
5966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5968 
      return
5969 
    iprot.readStructBegin()
5970 
    while True:
5971 
      (fname, ftype, fid) = iprot.readFieldBegin()
5972 
      if ftype == TType.STOP:
5973 
        break
5974 
      if fid == 1:
5975 
        if ftype == TType.I64:
5976 
          self.id = iprot.readI64();
5977 
        else:
5978 
          iprot.skip(ftype)
5979 
      else:
5980 
        iprot.skip(ftype)
5981 
      iprot.readFieldEnd()
5982 
    iprot.readStructEnd()
5983 
 
5984 
  def write(self, oprot):
5985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5987 
      return
5988 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5989 
    if self.id is not None:
94 ashish 5990 
      oprot.writeFieldBegin('id', TType.I64, 1)
5991 
      oprot.writeI64(self.id)
5992 
      oprot.writeFieldEnd()
5993 
    oprot.writeFieldStop()
5994 
    oprot.writeStructEnd()
5995 
 
3431 rajveer 5996 
  def validate(self):
5997 
    return
5998 
 
5999 
 
94 ashish 6000 
  def __repr__(self):
6001 
    L = ['%s=%r' % (key, value)
6002 
      for key, value in self.__dict__.iteritems()]
6003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6004 
 
6005 
  def __eq__(self, other):
6006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6007 
 
6008 
  def __ne__(self, other):
6009 
    return not (self == other)
6010 
 
6011 
class getTransaction_result:
6012 
  """
6013 
  Attributes:
6014 
   - success
6015 
   - ex
6016 
  """
6017 
 
6018 
  thrift_spec = (
6019 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6021 
  )
6022 
 
6023 
  def __init__(self, success=None, ex=None,):
6024 
    self.success = success
6025 
    self.ex = ex
6026 
 
6027 
  def read(self, iprot):
6028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6030 
      return
6031 
    iprot.readStructBegin()
6032 
    while True:
6033 
      (fname, ftype, fid) = iprot.readFieldBegin()
6034 
      if ftype == TType.STOP:
6035 
        break
6036 
      if fid == 0:
6037 
        if ftype == TType.STRUCT:
6038 
          self.success = Transaction()
6039 
          self.success.read(iprot)
6040 
        else:
6041 
          iprot.skip(ftype)
6042 
      elif fid == 1:
6043 
        if ftype == TType.STRUCT:
6044 
          self.ex = TransactionServiceException()
6045 
          self.ex.read(iprot)
6046 
        else:
6047 
          iprot.skip(ftype)
6048 
      else:
6049 
        iprot.skip(ftype)
6050 
      iprot.readFieldEnd()
6051 
    iprot.readStructEnd()
6052 
 
6053 
  def write(self, oprot):
6054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6056 
      return
6057 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6058 
    if self.success is not None:
94 ashish 6059 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6060 
      self.success.write(oprot)
6061 
      oprot.writeFieldEnd()
3431 rajveer 6062 
    if self.ex is not None:
94 ashish 6063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6064 
      self.ex.write(oprot)
6065 
      oprot.writeFieldEnd()
6066 
    oprot.writeFieldStop()
6067 
    oprot.writeStructEnd()
6068 
 
3431 rajveer 6069 
  def validate(self):
6070 
    return
6071 
 
6072 
 
94 ashish 6073 
  def __repr__(self):
6074 
    L = ['%s=%r' % (key, value)
6075 
      for key, value in self.__dict__.iteritems()]
6076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6077 
 
6078 
  def __eq__(self, other):
6079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6080 
 
6081 
  def __ne__(self, other):
6082 
    return not (self == other)
6083 
 
6084 
class getTransactionsForCustomer_args:
6085 
  """
6086 
  Attributes:
6087 
   - customerId
6088 
   - from_date
6089 
   - to_date
6090 
   - status
6091 
  """
6092 
 
6093 
  thrift_spec = (
6094 
    None, # 0
6095 
    (1, TType.I64, 'customerId', None, None, ), # 1
6096 
    (2, TType.I64, 'from_date', None, None, ), # 2
6097 
    (3, TType.I64, 'to_date', None, None, ), # 3
6098 
    (4, TType.I32, 'status', None, None, ), # 4
6099 
  )
6100 
 
6101 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6102 
    self.customerId = customerId
6103 
    self.from_date = from_date
6104 
    self.to_date = to_date
6105 
    self.status = status
6106 
 
6107 
  def read(self, iprot):
6108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6110 
      return
6111 
    iprot.readStructBegin()
6112 
    while True:
6113 
      (fname, ftype, fid) = iprot.readFieldBegin()
6114 
      if ftype == TType.STOP:
6115 
        break
6116 
      if fid == 1:
6117 
        if ftype == TType.I64:
6118 
          self.customerId = iprot.readI64();
6119 
        else:
6120 
          iprot.skip(ftype)
6121 
      elif fid == 2:
6122 
        if ftype == TType.I64:
6123 
          self.from_date = iprot.readI64();
6124 
        else:
6125 
          iprot.skip(ftype)
6126 
      elif fid == 3:
6127 
        if ftype == TType.I64:
6128 
          self.to_date = iprot.readI64();
6129 
        else:
6130 
          iprot.skip(ftype)
6131 
      elif fid == 4:
6132 
        if ftype == TType.I32:
6133 
          self.status = iprot.readI32();
6134 
        else:
6135 
          iprot.skip(ftype)
6136 
      else:
6137 
        iprot.skip(ftype)
6138 
      iprot.readFieldEnd()
6139 
    iprot.readStructEnd()
6140 
 
6141 
  def write(self, oprot):
6142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6144 
      return
6145 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6146 
    if self.customerId is not None:
94 ashish 6147 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6148 
      oprot.writeI64(self.customerId)
6149 
      oprot.writeFieldEnd()
3431 rajveer 6150 
    if self.from_date is not None:
94 ashish 6151 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6152 
      oprot.writeI64(self.from_date)
6153 
      oprot.writeFieldEnd()
3431 rajveer 6154 
    if self.to_date is not None:
94 ashish 6155 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6156 
      oprot.writeI64(self.to_date)
6157 
      oprot.writeFieldEnd()
3431 rajveer 6158 
    if self.status is not None:
94 ashish 6159 
      oprot.writeFieldBegin('status', TType.I32, 4)
6160 
      oprot.writeI32(self.status)
6161 
      oprot.writeFieldEnd()
6162 
    oprot.writeFieldStop()
6163 
    oprot.writeStructEnd()
6164 
 
3431 rajveer 6165 
  def validate(self):
6166 
    return
6167 
 
6168 
 
94 ashish 6169 
  def __repr__(self):
6170 
    L = ['%s=%r' % (key, value)
6171 
      for key, value in self.__dict__.iteritems()]
6172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6173 
 
6174 
  def __eq__(self, other):
6175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6176 
 
6177 
  def __ne__(self, other):
6178 
    return not (self == other)
6179 
 
6180 
class getTransactionsForCustomer_result:
6181 
  """
6182 
  Attributes:
6183 
   - success
6184 
   - ex
6185 
  """
6186 
 
6187 
  thrift_spec = (
6188 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6189 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6190 
  )
6191 
 
6192 
  def __init__(self, success=None, ex=None,):
6193 
    self.success = success
6194 
    self.ex = ex
6195 
 
6196 
  def read(self, iprot):
6197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6199 
      return
6200 
    iprot.readStructBegin()
6201 
    while True:
6202 
      (fname, ftype, fid) = iprot.readFieldBegin()
6203 
      if ftype == TType.STOP:
6204 
        break
6205 
      if fid == 0:
6206 
        if ftype == TType.LIST:
6207 
          self.success = []
685 chandransh 6208 
          (_etype17, _size14) = iprot.readListBegin()
6209 
          for _i18 in xrange(_size14):
6210 
            _elem19 = Transaction()
6211 
            _elem19.read(iprot)
6212 
            self.success.append(_elem19)
94 ashish 6213 
          iprot.readListEnd()
6214 
        else:
6215 
          iprot.skip(ftype)
6216 
      elif fid == 1:
6217 
        if ftype == TType.STRUCT:
6218 
          self.ex = TransactionServiceException()
6219 
          self.ex.read(iprot)
6220 
        else:
6221 
          iprot.skip(ftype)
6222 
      else:
6223 
        iprot.skip(ftype)
6224 
      iprot.readFieldEnd()
6225 
    iprot.readStructEnd()
6226 
 
6227 
  def write(self, oprot):
6228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6230 
      return
6231 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6232 
    if self.success is not None:
94 ashish 6233 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6234 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6235 
      for iter20 in self.success:
6236 
        iter20.write(oprot)
94 ashish 6237 
      oprot.writeListEnd()
6238 
      oprot.writeFieldEnd()
3431 rajveer 6239 
    if self.ex is not None:
94 ashish 6240 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6241 
      self.ex.write(oprot)
6242 
      oprot.writeFieldEnd()
6243 
    oprot.writeFieldStop()
6244 
    oprot.writeStructEnd()
6245 
 
3431 rajveer 6246 
  def validate(self):
6247 
    return
6248 
 
6249 
 
94 ashish 6250 
  def __repr__(self):
6251 
    L = ['%s=%r' % (key, value)
6252 
      for key, value in self.__dict__.iteritems()]
6253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6254 
 
6255 
  def __eq__(self, other):
6256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6257 
 
6258 
  def __ne__(self, other):
6259 
    return not (self == other)
6260 
 
132 ashish 6261 
class getTransactionsForShoppingCartId_args:
6262 
  """
6263 
  Attributes:
6264 
   - shoppingCartId
6265 
  """
6266 
 
6267 
  thrift_spec = (
6268 
    None, # 0
6269 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6270 
  )
6271 
 
6272 
  def __init__(self, shoppingCartId=None,):
6273 
    self.shoppingCartId = shoppingCartId
6274 
 
6275 
  def read(self, iprot):
6276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6278 
      return
6279 
    iprot.readStructBegin()
6280 
    while True:
6281 
      (fname, ftype, fid) = iprot.readFieldBegin()
6282 
      if ftype == TType.STOP:
6283 
        break
6284 
      if fid == 1:
6285 
        if ftype == TType.I64:
6286 
          self.shoppingCartId = iprot.readI64();
6287 
        else:
6288 
          iprot.skip(ftype)
6289 
      else:
6290 
        iprot.skip(ftype)
6291 
      iprot.readFieldEnd()
6292 
    iprot.readStructEnd()
6293 
 
6294 
  def write(self, oprot):
6295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6297 
      return
6298 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6299 
    if self.shoppingCartId is not None:
132 ashish 6300 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6301 
      oprot.writeI64(self.shoppingCartId)
6302 
      oprot.writeFieldEnd()
6303 
    oprot.writeFieldStop()
6304 
    oprot.writeStructEnd()
6305 
 
3431 rajveer 6306 
  def validate(self):
6307 
    return
6308 
 
6309 
 
132 ashish 6310 
  def __repr__(self):
6311 
    L = ['%s=%r' % (key, value)
6312 
      for key, value in self.__dict__.iteritems()]
6313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6314 
 
6315 
  def __eq__(self, other):
6316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6317 
 
6318 
  def __ne__(self, other):
6319 
    return not (self == other)
6320 
 
6321 
class getTransactionsForShoppingCartId_result:
6322 
  """
6323 
  Attributes:
6324 
   - success
6325 
   - ex
6326 
  """
6327 
 
6328 
  thrift_spec = (
6329 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6331 
  )
6332 
 
6333 
  def __init__(self, success=None, ex=None,):
6334 
    self.success = success
6335 
    self.ex = ex
6336 
 
6337 
  def read(self, iprot):
6338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6340 
      return
6341 
    iprot.readStructBegin()
6342 
    while True:
6343 
      (fname, ftype, fid) = iprot.readFieldBegin()
6344 
      if ftype == TType.STOP:
6345 
        break
6346 
      if fid == 0:
6347 
        if ftype == TType.LIST:
6348 
          self.success = []
685 chandransh 6349 
          (_etype24, _size21) = iprot.readListBegin()
6350 
          for _i25 in xrange(_size21):
6351 
            _elem26 = Transaction()
6352 
            _elem26.read(iprot)
6353 
            self.success.append(_elem26)
132 ashish 6354 
          iprot.readListEnd()
6355 
        else:
6356 
          iprot.skip(ftype)
6357 
      elif fid == 1:
6358 
        if ftype == TType.STRUCT:
6359 
          self.ex = TransactionServiceException()
6360 
          self.ex.read(iprot)
6361 
        else:
6362 
          iprot.skip(ftype)
6363 
      else:
6364 
        iprot.skip(ftype)
6365 
      iprot.readFieldEnd()
6366 
    iprot.readStructEnd()
6367 
 
6368 
  def write(self, oprot):
6369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6371 
      return
6372 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6373 
    if self.success is not None:
132 ashish 6374 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6375 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6376 
      for iter27 in self.success:
6377 
        iter27.write(oprot)
132 ashish 6378 
      oprot.writeListEnd()
6379 
      oprot.writeFieldEnd()
3431 rajveer 6380 
    if self.ex is not None:
132 ashish 6381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6382 
      self.ex.write(oprot)
6383 
      oprot.writeFieldEnd()
6384 
    oprot.writeFieldStop()
6385 
    oprot.writeStructEnd()
6386 
 
3431 rajveer 6387 
  def validate(self):
6388 
    return
6389 
 
6390 
 
132 ashish 6391 
  def __repr__(self):
6392 
    L = ['%s=%r' % (key, value)
6393 
      for key, value in self.__dict__.iteritems()]
6394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6395 
 
6396 
  def __eq__(self, other):
6397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6398 
 
6399 
  def __ne__(self, other):
6400 
    return not (self == other)
6401 
 
94 ashish 6402 
class getTransactionStatus_args:
6403 
  """
6404 
  Attributes:
6405 
   - transactionId
6406 
  """
6407 
 
6408 
  thrift_spec = (
6409 
    None, # 0
6410 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6411 
  )
6412 
 
6413 
  def __init__(self, transactionId=None,):
6414 
    self.transactionId = transactionId
6415 
 
6416 
  def read(self, iprot):
6417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6419 
      return
6420 
    iprot.readStructBegin()
6421 
    while True:
6422 
      (fname, ftype, fid) = iprot.readFieldBegin()
6423 
      if ftype == TType.STOP:
6424 
        break
6425 
      if fid == 1:
6426 
        if ftype == TType.I64:
6427 
          self.transactionId = iprot.readI64();
6428 
        else:
6429 
          iprot.skip(ftype)
6430 
      else:
6431 
        iprot.skip(ftype)
6432 
      iprot.readFieldEnd()
6433 
    iprot.readStructEnd()
6434 
 
6435 
  def write(self, oprot):
6436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6438 
      return
6439 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6440 
    if self.transactionId is not None:
94 ashish 6441 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6442 
      oprot.writeI64(self.transactionId)
6443 
      oprot.writeFieldEnd()
6444 
    oprot.writeFieldStop()
6445 
    oprot.writeStructEnd()
6446 
 
3431 rajveer 6447 
  def validate(self):
6448 
    return
6449 
 
6450 
 
94 ashish 6451 
  def __repr__(self):
6452 
    L = ['%s=%r' % (key, value)
6453 
      for key, value in self.__dict__.iteritems()]
6454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6455 
 
6456 
  def __eq__(self, other):
6457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6458 
 
6459 
  def __ne__(self, other):
6460 
    return not (self == other)
6461 
 
6462 
class getTransactionStatus_result:
6463 
  """
6464 
  Attributes:
6465 
   - success
6466 
   - ex
6467 
  """
6468 
 
6469 
  thrift_spec = (
6470 
    (0, TType.I32, 'success', None, None, ), # 0
6471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6472 
  )
6473 
 
6474 
  def __init__(self, success=None, ex=None,):
6475 
    self.success = success
6476 
    self.ex = ex
6477 
 
6478 
  def read(self, iprot):
6479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6481 
      return
6482 
    iprot.readStructBegin()
6483 
    while True:
6484 
      (fname, ftype, fid) = iprot.readFieldBegin()
6485 
      if ftype == TType.STOP:
6486 
        break
6487 
      if fid == 0:
6488 
        if ftype == TType.I32:
6489 
          self.success = iprot.readI32();
6490 
        else:
6491 
          iprot.skip(ftype)
6492 
      elif fid == 1:
6493 
        if ftype == TType.STRUCT:
6494 
          self.ex = TransactionServiceException()
6495 
          self.ex.read(iprot)
6496 
        else:
6497 
          iprot.skip(ftype)
6498 
      else:
6499 
        iprot.skip(ftype)
6500 
      iprot.readFieldEnd()
6501 
    iprot.readStructEnd()
6502 
 
6503 
  def write(self, oprot):
6504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6506 
      return
6507 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6508 
    if self.success is not None:
94 ashish 6509 
      oprot.writeFieldBegin('success', TType.I32, 0)
6510 
      oprot.writeI32(self.success)
6511 
      oprot.writeFieldEnd()
3431 rajveer 6512 
    if self.ex is not None:
94 ashish 6513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6514 
      self.ex.write(oprot)
6515 
      oprot.writeFieldEnd()
6516 
    oprot.writeFieldStop()
6517 
    oprot.writeStructEnd()
6518 
 
3431 rajveer 6519 
  def validate(self):
6520 
    return
6521 
 
6522 
 
94 ashish 6523 
  def __repr__(self):
6524 
    L = ['%s=%r' % (key, value)
6525 
      for key, value in self.__dict__.iteritems()]
6526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6527 
 
6528 
  def __eq__(self, other):
6529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6530 
 
6531 
  def __ne__(self, other):
6532 
    return not (self == other)
6533 
 
6534 
class changeTransactionStatus_args:
6535 
  """
6536 
  Attributes:
6537 
   - transactionId
6538 
   - status
6539 
   - description
6540 
  """
6541 
 
6542 
  thrift_spec = (
6543 
    None, # 0
6544 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6545 
    (2, TType.I32, 'status', None, None, ), # 2
6546 
    (3, TType.STRING, 'description', None, None, ), # 3
6547 
  )
6548 
 
6549 
  def __init__(self, transactionId=None, status=None, description=None,):
6550 
    self.transactionId = transactionId
6551 
    self.status = status
6552 
    self.description = description
6553 
 
6554 
  def read(self, iprot):
6555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6557 
      return
6558 
    iprot.readStructBegin()
6559 
    while True:
6560 
      (fname, ftype, fid) = iprot.readFieldBegin()
6561 
      if ftype == TType.STOP:
6562 
        break
6563 
      if fid == 1:
6564 
        if ftype == TType.I64:
6565 
          self.transactionId = iprot.readI64();
6566 
        else:
6567 
          iprot.skip(ftype)
6568 
      elif fid == 2:
6569 
        if ftype == TType.I32:
6570 
          self.status = iprot.readI32();
6571 
        else:
6572 
          iprot.skip(ftype)
6573 
      elif fid == 3:
6574 
        if ftype == TType.STRING:
6575 
          self.description = iprot.readString();
6576 
        else:
6577 
          iprot.skip(ftype)
6578 
      else:
6579 
        iprot.skip(ftype)
6580 
      iprot.readFieldEnd()
6581 
    iprot.readStructEnd()
6582 
 
6583 
  def write(self, oprot):
6584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6586 
      return
6587 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6588 
    if self.transactionId is not None:
94 ashish 6589 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6590 
      oprot.writeI64(self.transactionId)
6591 
      oprot.writeFieldEnd()
3431 rajveer 6592 
    if self.status is not None:
94 ashish 6593 
      oprot.writeFieldBegin('status', TType.I32, 2)
6594 
      oprot.writeI32(self.status)
6595 
      oprot.writeFieldEnd()
3431 rajveer 6596 
    if self.description is not None:
94 ashish 6597 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6598 
      oprot.writeString(self.description)
6599 
      oprot.writeFieldEnd()
6600 
    oprot.writeFieldStop()
6601 
    oprot.writeStructEnd()
6602 
 
3431 rajveer 6603 
  def validate(self):
6604 
    return
6605 
 
6606 
 
94 ashish 6607 
  def __repr__(self):
6608 
    L = ['%s=%r' % (key, value)
6609 
      for key, value in self.__dict__.iteritems()]
6610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6611 
 
6612 
  def __eq__(self, other):
6613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6614 
 
6615 
  def __ne__(self, other):
6616 
    return not (self == other)
6617 
 
6618 
class changeTransactionStatus_result:
6619 
  """
6620 
  Attributes:
6621 
   - success
6622 
   - ex
6623 
  """
6624 
 
6625 
  thrift_spec = (
6626 
    (0, TType.BOOL, 'success', None, None, ), # 0
6627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6628 
  )
6629 
 
6630 
  def __init__(self, success=None, ex=None,):
6631 
    self.success = success
6632 
    self.ex = ex
6633 
 
6634 
  def read(self, iprot):
6635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6637 
      return
6638 
    iprot.readStructBegin()
6639 
    while True:
6640 
      (fname, ftype, fid) = iprot.readFieldBegin()
6641 
      if ftype == TType.STOP:
6642 
        break
6643 
      if fid == 0:
6644 
        if ftype == TType.BOOL:
6645 
          self.success = iprot.readBool();
6646 
        else:
6647 
          iprot.skip(ftype)
6648 
      elif fid == 1:
6649 
        if ftype == TType.STRUCT:
6650 
          self.ex = TransactionServiceException()
6651 
          self.ex.read(iprot)
6652 
        else:
6653 
          iprot.skip(ftype)
6654 
      else:
6655 
        iprot.skip(ftype)
6656 
      iprot.readFieldEnd()
6657 
    iprot.readStructEnd()
6658 
 
6659 
  def write(self, oprot):
6660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6662 
      return
6663 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6664 
    if self.success is not None:
94 ashish 6665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6666 
      oprot.writeBool(self.success)
6667 
      oprot.writeFieldEnd()
3431 rajveer 6668 
    if self.ex is not None:
94 ashish 6669 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6670 
      self.ex.write(oprot)
6671 
      oprot.writeFieldEnd()
6672 
    oprot.writeFieldStop()
6673 
    oprot.writeStructEnd()
6674 
 
3431 rajveer 6675 
  def validate(self):
6676 
    return
6677 
 
6678 
 
94 ashish 6679 
  def __repr__(self):
6680 
    L = ['%s=%r' % (key, value)
6681 
      for key, value in self.__dict__.iteritems()]
6682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6683 
 
6684 
  def __eq__(self, other):
6685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6686 
 
6687 
  def __ne__(self, other):
6688 
    return not (self == other)
6689 
 
1398 varun.gupt 6690 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6691 
  """
6692 
  Attributes:
6693 
   - transactionId
6694 
  """
6695 
 
6696 
  thrift_spec = (
6697 
    None, # 0
6698 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6699 
  )
6700 
 
6701 
  def __init__(self, transactionId=None,):
6702 
    self.transactionId = transactionId
6703 
 
6704 
  def read(self, iprot):
6705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6707 
      return
6708 
    iprot.readStructBegin()
6709 
    while True:
6710 
      (fname, ftype, fid) = iprot.readFieldBegin()
6711 
      if ftype == TType.STOP:
6712 
        break
6713 
      if fid == 1:
6714 
        if ftype == TType.I64:
6715 
          self.transactionId = iprot.readI64();
6716 
        else:
6717 
          iprot.skip(ftype)
6718 
      else:
6719 
        iprot.skip(ftype)
6720 
      iprot.readFieldEnd()
6721 
    iprot.readStructEnd()
6722 
 
6723 
  def write(self, oprot):
6724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6726 
      return
1398 varun.gupt 6727 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6728 
    if self.transactionId is not None:
1382 varun.gupt 6729 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6730 
      oprot.writeI64(self.transactionId)
6731 
      oprot.writeFieldEnd()
6732 
    oprot.writeFieldStop()
6733 
    oprot.writeStructEnd()
6734 
 
3431 rajveer 6735 
  def validate(self):
6736 
    return
6737 
 
6738 
 
1382 varun.gupt 6739 
  def __repr__(self):
6740 
    L = ['%s=%r' % (key, value)
6741 
      for key, value in self.__dict__.iteritems()]
6742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6743 
 
6744 
  def __eq__(self, other):
6745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6746 
 
6747 
  def __ne__(self, other):
6748 
    return not (self == other)
6749 
 
1398 varun.gupt 6750 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6751 
  """
6752 
  Attributes:
6753 
   - success
6754 
   - ex
6755 
  """
6756 
 
6757 
  thrift_spec = (
6758 
    (0, TType.BOOL, 'success', None, None, ), # 0
6759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6760 
  )
6761 
 
6762 
  def __init__(self, success=None, ex=None,):
6763 
    self.success = success
6764 
    self.ex = ex
6765 
 
6766 
  def read(self, iprot):
6767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6769 
      return
6770 
    iprot.readStructBegin()
6771 
    while True:
6772 
      (fname, ftype, fid) = iprot.readFieldBegin()
6773 
      if ftype == TType.STOP:
6774 
        break
6775 
      if fid == 0:
6776 
        if ftype == TType.BOOL:
6777 
          self.success = iprot.readBool();
6778 
        else:
6779 
          iprot.skip(ftype)
6780 
      elif fid == 1:
6781 
        if ftype == TType.STRUCT:
6782 
          self.ex = TransactionServiceException()
6783 
          self.ex.read(iprot)
6784 
        else:
6785 
          iprot.skip(ftype)
6786 
      else:
6787 
        iprot.skip(ftype)
6788 
      iprot.readFieldEnd()
6789 
    iprot.readStructEnd()
6790 
 
6791 
  def write(self, oprot):
6792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6794 
      return
1398 varun.gupt 6795 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6796 
    if self.success is not None:
1382 varun.gupt 6797 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6798 
      oprot.writeBool(self.success)
6799 
      oprot.writeFieldEnd()
3431 rajveer 6800 
    if self.ex is not None:
1382 varun.gupt 6801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6802 
      self.ex.write(oprot)
6803 
      oprot.writeFieldEnd()
6804 
    oprot.writeFieldStop()
6805 
    oprot.writeStructEnd()
6806 
 
3431 rajveer 6807 
  def validate(self):
6808 
    return
6809 
 
6810 
 
1382 varun.gupt 6811 
  def __repr__(self):
6812 
    L = ['%s=%r' % (key, value)
6813 
      for key, value in self.__dict__.iteritems()]
6814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6815 
 
6816 
  def __eq__(self, other):
6817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6818 
 
6819 
  def __ne__(self, other):
6820 
    return not (self == other)
6821 
 
483 rajveer 6822 
class getAllOrders_args:
94 ashish 6823 
  """
6824 
  Attributes:
483 rajveer 6825 
   - status
6826 
   - from_date
6827 
   - to_date
6828 
   - warehouse_id
94 ashish 6829 
  """
6830 
 
6831 
  thrift_spec = (
6832 
    None, # 0
483 rajveer 6833 
    (1, TType.I32, 'status', None, None, ), # 1
6834 
    (2, TType.I64, 'from_date', None, None, ), # 2
6835 
    (3, TType.I64, 'to_date', None, None, ), # 3
6836 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6837 
  )
6838 
 
483 rajveer 6839 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6840 
    self.status = status
6841 
    self.from_date = from_date
6842 
    self.to_date = to_date
6843 
    self.warehouse_id = warehouse_id
94 ashish 6844 
 
6845 
  def read(self, iprot):
6846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6848 
      return
6849 
    iprot.readStructBegin()
6850 
    while True:
6851 
      (fname, ftype, fid) = iprot.readFieldBegin()
6852 
      if ftype == TType.STOP:
6853 
        break
6854 
      if fid == 1:
483 rajveer 6855 
        if ftype == TType.I32:
6856 
          self.status = iprot.readI32();
94 ashish 6857 
        else:
6858 
          iprot.skip(ftype)
483 rajveer 6859 
      elif fid == 2:
6860 
        if ftype == TType.I64:
6861 
          self.from_date = iprot.readI64();
94 ashish 6862 
        else:
6863 
          iprot.skip(ftype)
483 rajveer 6864 
      elif fid == 3:
6865 
        if ftype == TType.I64:
6866 
          self.to_date = iprot.readI64();
94 ashish 6867 
        else:
6868 
          iprot.skip(ftype)
483 rajveer 6869 
      elif fid == 4:
94 ashish 6870 
        if ftype == TType.I64:
483 rajveer 6871 
          self.warehouse_id = iprot.readI64();
94 ashish 6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      else:
6875 
        iprot.skip(ftype)
6876 
      iprot.readFieldEnd()
6877 
    iprot.readStructEnd()
6878 
 
6879 
  def write(self, oprot):
6880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6882 
      return
483 rajveer 6883 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6884 
    if self.status is not None:
483 rajveer 6885 
      oprot.writeFieldBegin('status', TType.I32, 1)
6886 
      oprot.writeI32(self.status)
94 ashish 6887 
      oprot.writeFieldEnd()
3431 rajveer 6888 
    if self.from_date is not None:
483 rajveer 6889 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6890 
      oprot.writeI64(self.from_date)
94 ashish 6891 
      oprot.writeFieldEnd()
3431 rajveer 6892 
    if self.to_date is not None:
483 rajveer 6893 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6894 
      oprot.writeI64(self.to_date)
94 ashish 6895 
      oprot.writeFieldEnd()
3431 rajveer 6896 
    if self.warehouse_id is not None:
483 rajveer 6897 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6898 
      oprot.writeI64(self.warehouse_id)
94 ashish 6899 
      oprot.writeFieldEnd()
6900 
    oprot.writeFieldStop()
6901 
    oprot.writeStructEnd()
6902 
 
3431 rajveer 6903 
  def validate(self):
6904 
    return
6905 
 
6906 
 
94 ashish 6907 
  def __repr__(self):
6908 
    L = ['%s=%r' % (key, value)
6909 
      for key, value in self.__dict__.iteritems()]
6910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6911 
 
6912 
  def __eq__(self, other):
6913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6914 
 
6915 
  def __ne__(self, other):
6916 
    return not (self == other)
6917 
 
483 rajveer 6918 
class getAllOrders_result:
94 ashish 6919 
  """
6920 
  Attributes:
6921 
   - success
6922 
   - ex
6923 
  """
6924 
 
6925 
  thrift_spec = (
483 rajveer 6926 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6927 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6928 
  )
6929 
 
6930 
  def __init__(self, success=None, ex=None,):
6931 
    self.success = success
6932 
    self.ex = ex
6933 
 
6934 
  def read(self, iprot):
6935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6937 
      return
6938 
    iprot.readStructBegin()
6939 
    while True:
6940 
      (fname, ftype, fid) = iprot.readFieldBegin()
6941 
      if ftype == TType.STOP:
6942 
        break
6943 
      if fid == 0:
483 rajveer 6944 
        if ftype == TType.LIST:
6945 
          self.success = []
685 chandransh 6946 
          (_etype31, _size28) = iprot.readListBegin()
6947 
          for _i32 in xrange(_size28):
6948 
            _elem33 = Order()
6949 
            _elem33.read(iprot)
6950 
            self.success.append(_elem33)
483 rajveer 6951 
          iprot.readListEnd()
94 ashish 6952 
        else:
6953 
          iprot.skip(ftype)
6954 
      elif fid == 1:
6955 
        if ftype == TType.STRUCT:
6956 
          self.ex = TransactionServiceException()
6957 
          self.ex.read(iprot)
6958 
        else:
6959 
          iprot.skip(ftype)
6960 
      else:
6961 
        iprot.skip(ftype)
6962 
      iprot.readFieldEnd()
6963 
    iprot.readStructEnd()
6964 
 
6965 
  def write(self, oprot):
6966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6968 
      return
483 rajveer 6969 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6970 
    if self.success is not None:
483 rajveer 6971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6973 
      for iter34 in self.success:
6974 
        iter34.write(oprot)
483 rajveer 6975 
      oprot.writeListEnd()
94 ashish 6976 
      oprot.writeFieldEnd()
3431 rajveer 6977 
    if self.ex is not None:
94 ashish 6978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6979 
      self.ex.write(oprot)
6980 
      oprot.writeFieldEnd()
6981 
    oprot.writeFieldStop()
6982 
    oprot.writeStructEnd()
6983 
 
3431 rajveer 6984 
  def validate(self):
6985 
    return
6986 
 
6987 
 
94 ashish 6988 
  def __repr__(self):
6989 
    L = ['%s=%r' % (key, value)
6990 
      for key, value in self.__dict__.iteritems()]
6991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6992 
 
6993 
  def __eq__(self, other):
6994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6995 
 
6996 
  def __ne__(self, other):
6997 
    return not (self == other)
6998 
 
4133 chandransh 6999 
class getOrdersInBatch_args:
7000 
  """
7001 
  Attributes:
7002 
   - statuses
7003 
   - offset
7004 
   - limit
7005 
   - warehouse_id
7006 
  """
7007 
 
7008 
  thrift_spec = (
7009 
    None, # 0
7010 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7011 
    (2, TType.I64, 'offset', None, None, ), # 2
7012 
    (3, TType.I64, 'limit', None, None, ), # 3
7013 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7014 
  )
7015 
 
7016 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7017 
    self.statuses = statuses
7018 
    self.offset = offset
7019 
    self.limit = limit
7020 
    self.warehouse_id = warehouse_id
7021 
 
7022 
  def read(self, iprot):
7023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7025 
      return
7026 
    iprot.readStructBegin()
7027 
    while True:
7028 
      (fname, ftype, fid) = iprot.readFieldBegin()
7029 
      if ftype == TType.STOP:
7030 
        break
7031 
      if fid == 1:
7032 
        if ftype == TType.LIST:
7033 
          self.statuses = []
7034 
          (_etype38, _size35) = iprot.readListBegin()
7035 
          for _i39 in xrange(_size35):
7036 
            _elem40 = iprot.readI32();
7037 
            self.statuses.append(_elem40)
7038 
          iprot.readListEnd()
7039 
        else:
7040 
          iprot.skip(ftype)
7041 
      elif fid == 2:
7042 
        if ftype == TType.I64:
7043 
          self.offset = iprot.readI64();
7044 
        else:
7045 
          iprot.skip(ftype)
7046 
      elif fid == 3:
7047 
        if ftype == TType.I64:
7048 
          self.limit = iprot.readI64();
7049 
        else:
7050 
          iprot.skip(ftype)
7051 
      elif fid == 4:
7052 
        if ftype == TType.I64:
7053 
          self.warehouse_id = iprot.readI64();
7054 
        else:
7055 
          iprot.skip(ftype)
7056 
      else:
7057 
        iprot.skip(ftype)
7058 
      iprot.readFieldEnd()
7059 
    iprot.readStructEnd()
7060 
 
7061 
  def write(self, oprot):
7062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7064 
      return
7065 
    oprot.writeStructBegin('getOrdersInBatch_args')
7066 
    if self.statuses is not None:
7067 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7068 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7069 
      for iter41 in self.statuses:
7070 
        oprot.writeI32(iter41)
7071 
      oprot.writeListEnd()
7072 
      oprot.writeFieldEnd()
7073 
    if self.offset is not None:
7074 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7075 
      oprot.writeI64(self.offset)
7076 
      oprot.writeFieldEnd()
7077 
    if self.limit is not None:
7078 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7079 
      oprot.writeI64(self.limit)
7080 
      oprot.writeFieldEnd()
7081 
    if self.warehouse_id is not None:
7082 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7083 
      oprot.writeI64(self.warehouse_id)
7084 
      oprot.writeFieldEnd()
7085 
    oprot.writeFieldStop()
7086 
    oprot.writeStructEnd()
7087 
 
7088 
  def validate(self):
7089 
    return
7090 
 
7091 
 
7092 
  def __repr__(self):
7093 
    L = ['%s=%r' % (key, value)
7094 
      for key, value in self.__dict__.iteritems()]
7095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7096 
 
7097 
  def __eq__(self, other):
7098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7099 
 
7100 
  def __ne__(self, other):
7101 
    return not (self == other)
7102 
 
7103 
class getOrdersInBatch_result:
7104 
  """
7105 
  Attributes:
7106 
   - success
7107 
   - ex
7108 
  """
7109 
 
7110 
  thrift_spec = (
7111 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7113 
  )
7114 
 
7115 
  def __init__(self, success=None, ex=None,):
7116 
    self.success = success
7117 
    self.ex = ex
7118 
 
7119 
  def read(self, iprot):
7120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7122 
      return
7123 
    iprot.readStructBegin()
7124 
    while True:
7125 
      (fname, ftype, fid) = iprot.readFieldBegin()
7126 
      if ftype == TType.STOP:
7127 
        break
7128 
      if fid == 0:
7129 
        if ftype == TType.LIST:
7130 
          self.success = []
7131 
          (_etype45, _size42) = iprot.readListBegin()
7132 
          for _i46 in xrange(_size42):
7133 
            _elem47 = Order()
7134 
            _elem47.read(iprot)
7135 
            self.success.append(_elem47)
7136 
          iprot.readListEnd()
7137 
        else:
7138 
          iprot.skip(ftype)
7139 
      elif fid == 1:
7140 
        if ftype == TType.STRUCT:
7141 
          self.ex = TransactionServiceException()
7142 
          self.ex.read(iprot)
7143 
        else:
7144 
          iprot.skip(ftype)
7145 
      else:
7146 
        iprot.skip(ftype)
7147 
      iprot.readFieldEnd()
7148 
    iprot.readStructEnd()
7149 
 
7150 
  def write(self, oprot):
7151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7153 
      return
7154 
    oprot.writeStructBegin('getOrdersInBatch_result')
7155 
    if self.success is not None:
7156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7158 
      for iter48 in self.success:
7159 
        iter48.write(oprot)
7160 
      oprot.writeListEnd()
7161 
      oprot.writeFieldEnd()
7162 
    if self.ex is not None:
7163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7164 
      self.ex.write(oprot)
7165 
      oprot.writeFieldEnd()
7166 
    oprot.writeFieldStop()
7167 
    oprot.writeStructEnd()
7168 
 
7169 
  def validate(self):
7170 
    return
7171 
 
7172 
 
7173 
  def __repr__(self):
7174 
    L = ['%s=%r' % (key, value)
7175 
      for key, value in self.__dict__.iteritems()]
7176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7177 
 
7178 
  def __eq__(self, other):
7179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7180 
 
7181 
  def __ne__(self, other):
7182 
    return not (self == other)
7183 
 
7184 
class getOrderCount_args:
7185 
  """
7186 
  Attributes:
7187 
   - statuses
7188 
   - warehouseId
7189 
  """
7190 
 
7191 
  thrift_spec = (
7192 
    None, # 0
7193 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7194 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7195 
  )
7196 
 
7197 
  def __init__(self, statuses=None, warehouseId=None,):
7198 
    self.statuses = statuses
7199 
    self.warehouseId = warehouseId
7200 
 
7201 
  def read(self, iprot):
7202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7204 
      return
7205 
    iprot.readStructBegin()
7206 
    while True:
7207 
      (fname, ftype, fid) = iprot.readFieldBegin()
7208 
      if ftype == TType.STOP:
7209 
        break
7210 
      if fid == 1:
7211 
        if ftype == TType.LIST:
7212 
          self.statuses = []
7213 
          (_etype52, _size49) = iprot.readListBegin()
7214 
          for _i53 in xrange(_size49):
7215 
            _elem54 = iprot.readI32();
7216 
            self.statuses.append(_elem54)
7217 
          iprot.readListEnd()
7218 
        else:
7219 
          iprot.skip(ftype)
7220 
      elif fid == 2:
7221 
        if ftype == TType.I64:
7222 
          self.warehouseId = iprot.readI64();
7223 
        else:
7224 
          iprot.skip(ftype)
7225 
      else:
7226 
        iprot.skip(ftype)
7227 
      iprot.readFieldEnd()
7228 
    iprot.readStructEnd()
7229 
 
7230 
  def write(self, oprot):
7231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7233 
      return
7234 
    oprot.writeStructBegin('getOrderCount_args')
7235 
    if self.statuses is not None:
7236 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7237 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7238 
      for iter55 in self.statuses:
7239 
        oprot.writeI32(iter55)
7240 
      oprot.writeListEnd()
7241 
      oprot.writeFieldEnd()
7242 
    if self.warehouseId is not None:
7243 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7244 
      oprot.writeI64(self.warehouseId)
7245 
      oprot.writeFieldEnd()
7246 
    oprot.writeFieldStop()
7247 
    oprot.writeStructEnd()
7248 
 
7249 
  def validate(self):
7250 
    return
7251 
 
7252 
 
7253 
  def __repr__(self):
7254 
    L = ['%s=%r' % (key, value)
7255 
      for key, value in self.__dict__.iteritems()]
7256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7257 
 
7258 
  def __eq__(self, other):
7259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7260 
 
7261 
  def __ne__(self, other):
7262 
    return not (self == other)
7263 
 
7264 
class getOrderCount_result:
7265 
  """
7266 
  Attributes:
7267 
   - success
7268 
   - ex
7269 
  """
7270 
 
7271 
  thrift_spec = (
7272 
    (0, TType.I32, 'success', None, None, ), # 0
7273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7274 
  )
7275 
 
7276 
  def __init__(self, success=None, ex=None,):
7277 
    self.success = success
7278 
    self.ex = ex
7279 
 
7280 
  def read(self, iprot):
7281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7283 
      return
7284 
    iprot.readStructBegin()
7285 
    while True:
7286 
      (fname, ftype, fid) = iprot.readFieldBegin()
7287 
      if ftype == TType.STOP:
7288 
        break
7289 
      if fid == 0:
7290 
        if ftype == TType.I32:
7291 
          self.success = iprot.readI32();
7292 
        else:
7293 
          iprot.skip(ftype)
7294 
      elif fid == 1:
7295 
        if ftype == TType.STRUCT:
7296 
          self.ex = TransactionServiceException()
7297 
          self.ex.read(iprot)
7298 
        else:
7299 
          iprot.skip(ftype)
7300 
      else:
7301 
        iprot.skip(ftype)
7302 
      iprot.readFieldEnd()
7303 
    iprot.readStructEnd()
7304 
 
7305 
  def write(self, oprot):
7306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7308 
      return
7309 
    oprot.writeStructBegin('getOrderCount_result')
7310 
    if self.success is not None:
7311 
      oprot.writeFieldBegin('success', TType.I32, 0)
7312 
      oprot.writeI32(self.success)
7313 
      oprot.writeFieldEnd()
7314 
    if self.ex is not None:
7315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7316 
      self.ex.write(oprot)
7317 
      oprot.writeFieldEnd()
7318 
    oprot.writeFieldStop()
7319 
    oprot.writeStructEnd()
7320 
 
7321 
  def validate(self):
7322 
    return
7323 
 
7324 
 
7325 
  def __repr__(self):
7326 
    L = ['%s=%r' % (key, value)
7327 
      for key, value in self.__dict__.iteritems()]
7328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7329 
 
7330 
  def __eq__(self, other):
7331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7332 
 
7333 
  def __ne__(self, other):
7334 
    return not (self == other)
7335 
 
999 varun.gupt 7336 
class getOrdersByBillingDate_args:
7337 
  """
7338 
  Attributes:
7339 
   - status
7340 
   - start_billing_date
7341 
   - end_billing_date
7342 
   - warehouse_id
7343 
  """
7344 
 
7345 
  thrift_spec = (
7346 
    None, # 0
7347 
    (1, TType.I32, 'status', None, None, ), # 1
7348 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7349 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7350 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7351 
  )
7352 
 
7353 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7354 
    self.status = status
7355 
    self.start_billing_date = start_billing_date
7356 
    self.end_billing_date = end_billing_date
7357 
    self.warehouse_id = warehouse_id
7358 
 
7359 
  def read(self, iprot):
7360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7362 
      return
7363 
    iprot.readStructBegin()
7364 
    while True:
7365 
      (fname, ftype, fid) = iprot.readFieldBegin()
7366 
      if ftype == TType.STOP:
7367 
        break
7368 
      if fid == 1:
7369 
        if ftype == TType.I32:
7370 
          self.status = iprot.readI32();
7371 
        else:
7372 
          iprot.skip(ftype)
7373 
      elif fid == 2:
7374 
        if ftype == TType.I64:
7375 
          self.start_billing_date = iprot.readI64();
7376 
        else:
7377 
          iprot.skip(ftype)
7378 
      elif fid == 3:
7379 
        if ftype == TType.I64:
7380 
          self.end_billing_date = iprot.readI64();
7381 
        else:
7382 
          iprot.skip(ftype)
7383 
      elif fid == 4:
7384 
        if ftype == TType.I64:
7385 
          self.warehouse_id = iprot.readI64();
7386 
        else:
7387 
          iprot.skip(ftype)
7388 
      else:
7389 
        iprot.skip(ftype)
7390 
      iprot.readFieldEnd()
7391 
    iprot.readStructEnd()
7392 
 
7393 
  def write(self, oprot):
7394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7396 
      return
7397 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7398 
    if self.status is not None:
999 varun.gupt 7399 
      oprot.writeFieldBegin('status', TType.I32, 1)
7400 
      oprot.writeI32(self.status)
7401 
      oprot.writeFieldEnd()
3431 rajveer 7402 
    if self.start_billing_date is not None:
999 varun.gupt 7403 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7404 
      oprot.writeI64(self.start_billing_date)
7405 
      oprot.writeFieldEnd()
3431 rajveer 7406 
    if self.end_billing_date is not None:
999 varun.gupt 7407 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7408 
      oprot.writeI64(self.end_billing_date)
7409 
      oprot.writeFieldEnd()
3431 rajveer 7410 
    if self.warehouse_id is not None:
999 varun.gupt 7411 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7412 
      oprot.writeI64(self.warehouse_id)
7413 
      oprot.writeFieldEnd()
7414 
    oprot.writeFieldStop()
7415 
    oprot.writeStructEnd()
7416 
 
3431 rajveer 7417 
  def validate(self):
7418 
    return
7419 
 
7420 
 
999 varun.gupt 7421 
  def __repr__(self):
7422 
    L = ['%s=%r' % (key, value)
7423 
      for key, value in self.__dict__.iteritems()]
7424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7425 
 
7426 
  def __eq__(self, other):
7427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7428 
 
7429 
  def __ne__(self, other):
7430 
    return not (self == other)
7431 
 
7432 
class getOrdersByBillingDate_result:
7433 
  """
7434 
  Attributes:
7435 
   - success
7436 
   - ex
7437 
  """
7438 
 
7439 
  thrift_spec = (
7440 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7441 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7442 
  )
7443 
 
7444 
  def __init__(self, success=None, ex=None,):
7445 
    self.success = success
7446 
    self.ex = ex
7447 
 
7448 
  def read(self, iprot):
7449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7451 
      return
7452 
    iprot.readStructBegin()
7453 
    while True:
7454 
      (fname, ftype, fid) = iprot.readFieldBegin()
7455 
      if ftype == TType.STOP:
7456 
        break
7457 
      if fid == 0:
7458 
        if ftype == TType.LIST:
7459 
          self.success = []
4133 chandransh 7460 
          (_etype59, _size56) = iprot.readListBegin()
7461 
          for _i60 in xrange(_size56):
7462 
            _elem61 = Order()
7463 
            _elem61.read(iprot)
7464 
            self.success.append(_elem61)
999 varun.gupt 7465 
          iprot.readListEnd()
7466 
        else:
7467 
          iprot.skip(ftype)
7468 
      elif fid == 1:
7469 
        if ftype == TType.STRUCT:
7470 
          self.ex = TransactionServiceException()
7471 
          self.ex.read(iprot)
7472 
        else:
7473 
          iprot.skip(ftype)
7474 
      else:
7475 
        iprot.skip(ftype)
7476 
      iprot.readFieldEnd()
7477 
    iprot.readStructEnd()
7478 
 
7479 
  def write(self, oprot):
7480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7482 
      return
7483 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7484 
    if self.success is not None:
999 varun.gupt 7485 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7486 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7487 
      for iter62 in self.success:
7488 
        iter62.write(oprot)
999 varun.gupt 7489 
      oprot.writeListEnd()
7490 
      oprot.writeFieldEnd()
3431 rajveer 7491 
    if self.ex is not None:
999 varun.gupt 7492 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7493 
      self.ex.write(oprot)
7494 
      oprot.writeFieldEnd()
7495 
    oprot.writeFieldStop()
7496 
    oprot.writeStructEnd()
7497 
 
3431 rajveer 7498 
  def validate(self):
7499 
    return
7500 
 
7501 
 
999 varun.gupt 7502 
  def __repr__(self):
7503 
    L = ['%s=%r' % (key, value)
7504 
      for key, value in self.__dict__.iteritems()]
7505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7506 
 
7507 
  def __eq__(self, other):
7508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7509 
 
7510 
  def __ne__(self, other):
7511 
    return not (self == other)
7512 
 
3427 chandransh 7513 
class getOrdersByShippingDate_args:
7514 
  """
7515 
  Attributes:
7516 
   - fromShippingDate
7517 
   - toShippingDate
7518 
   - providerId
7519 
   - warehouseId
3451 chandransh 7520 
   - cod
3427 chandransh 7521 
  """
7522 
 
7523 
  thrift_spec = (
7524 
    None, # 0
7525 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7526 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7527 
    (3, TType.I64, 'providerId', None, None, ), # 3
7528 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7529 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7530 
  )
7531 
 
3451 chandransh 7532 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7533 
    self.fromShippingDate = fromShippingDate
7534 
    self.toShippingDate = toShippingDate
7535 
    self.providerId = providerId
7536 
    self.warehouseId = warehouseId
3451 chandransh 7537 
    self.cod = cod
3427 chandransh 7538 
 
7539 
  def read(self, iprot):
7540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7542 
      return
7543 
    iprot.readStructBegin()
7544 
    while True:
7545 
      (fname, ftype, fid) = iprot.readFieldBegin()
7546 
      if ftype == TType.STOP:
7547 
        break
7548 
      if fid == 1:
7549 
        if ftype == TType.I64:
7550 
          self.fromShippingDate = iprot.readI64();
7551 
        else:
7552 
          iprot.skip(ftype)
7553 
      elif fid == 2:
7554 
        if ftype == TType.I64:
7555 
          self.toShippingDate = iprot.readI64();
7556 
        else:
7557 
          iprot.skip(ftype)
7558 
      elif fid == 3:
7559 
        if ftype == TType.I64:
7560 
          self.providerId = iprot.readI64();
7561 
        else:
7562 
          iprot.skip(ftype)
7563 
      elif fid == 4:
7564 
        if ftype == TType.I64:
7565 
          self.warehouseId = iprot.readI64();
7566 
        else:
7567 
          iprot.skip(ftype)
3451 chandransh 7568 
      elif fid == 5:
7569 
        if ftype == TType.BOOL:
7570 
          self.cod = iprot.readBool();
7571 
        else:
7572 
          iprot.skip(ftype)
3427 chandransh 7573 
      else:
7574 
        iprot.skip(ftype)
7575 
      iprot.readFieldEnd()
7576 
    iprot.readStructEnd()
7577 
 
7578 
  def write(self, oprot):
7579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7581 
      return
7582 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7583 
    if self.fromShippingDate is not None:
3427 chandransh 7584 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7585 
      oprot.writeI64(self.fromShippingDate)
7586 
      oprot.writeFieldEnd()
3431 rajveer 7587 
    if self.toShippingDate is not None:
3427 chandransh 7588 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7589 
      oprot.writeI64(self.toShippingDate)
7590 
      oprot.writeFieldEnd()
3431 rajveer 7591 
    if self.providerId is not None:
3427 chandransh 7592 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7593 
      oprot.writeI64(self.providerId)
7594 
      oprot.writeFieldEnd()
3431 rajveer 7595 
    if self.warehouseId is not None:
3427 chandransh 7596 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7597 
      oprot.writeI64(self.warehouseId)
7598 
      oprot.writeFieldEnd()
3451 chandransh 7599 
    if self.cod is not None:
7600 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7601 
      oprot.writeBool(self.cod)
7602 
      oprot.writeFieldEnd()
3427 chandransh 7603 
    oprot.writeFieldStop()
7604 
    oprot.writeStructEnd()
7605 
 
3431 rajveer 7606 
  def validate(self):
7607 
    return
7608 
 
7609 
 
3427 chandransh 7610 
  def __repr__(self):
7611 
    L = ['%s=%r' % (key, value)
7612 
      for key, value in self.__dict__.iteritems()]
7613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7614 
 
7615 
  def __eq__(self, other):
7616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7617 
 
7618 
  def __ne__(self, other):
7619 
    return not (self == other)
7620 
 
7621 
class getOrdersByShippingDate_result:
7622 
  """
7623 
  Attributes:
7624 
   - success
7625 
   - ex
7626 
  """
7627 
 
7628 
  thrift_spec = (
7629 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7631 
  )
7632 
 
7633 
  def __init__(self, success=None, ex=None,):
7634 
    self.success = success
7635 
    self.ex = ex
7636 
 
7637 
  def read(self, iprot):
7638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7640 
      return
7641 
    iprot.readStructBegin()
7642 
    while True:
7643 
      (fname, ftype, fid) = iprot.readFieldBegin()
7644 
      if ftype == TType.STOP:
7645 
        break
7646 
      if fid == 0:
7647 
        if ftype == TType.LIST:
7648 
          self.success = []
4133 chandransh 7649 
          (_etype66, _size63) = iprot.readListBegin()
7650 
          for _i67 in xrange(_size63):
7651 
            _elem68 = Order()
7652 
            _elem68.read(iprot)
7653 
            self.success.append(_elem68)
3427 chandransh 7654 
          iprot.readListEnd()
7655 
        else:
7656 
          iprot.skip(ftype)
7657 
      elif fid == 1:
7658 
        if ftype == TType.STRUCT:
7659 
          self.ex = TransactionServiceException()
7660 
          self.ex.read(iprot)
7661 
        else:
7662 
          iprot.skip(ftype)
7663 
      else:
7664 
        iprot.skip(ftype)
7665 
      iprot.readFieldEnd()
7666 
    iprot.readStructEnd()
7667 
 
7668 
  def write(self, oprot):
7669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7671 
      return
7672 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7673 
    if self.success is not None:
3427 chandransh 7674 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7675 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7676 
      for iter69 in self.success:
7677 
        iter69.write(oprot)
3427 chandransh 7678 
      oprot.writeListEnd()
7679 
      oprot.writeFieldEnd()
3431 rajveer 7680 
    if self.ex is not None:
3427 chandransh 7681 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7682 
      self.ex.write(oprot)
7683 
      oprot.writeFieldEnd()
7684 
    oprot.writeFieldStop()
7685 
    oprot.writeStructEnd()
7686 
 
3431 rajveer 7687 
  def validate(self):
7688 
    return
7689 
 
7690 
 
3427 chandransh 7691 
  def __repr__(self):
7692 
    L = ['%s=%r' % (key, value)
7693 
      for key, value in self.__dict__.iteritems()]
7694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7695 
 
7696 
  def __eq__(self, other):
7697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7698 
 
7699 
  def __ne__(self, other):
7700 
    return not (self == other)
7701 
 
1382 varun.gupt 7702 
class getReturnableOrdersForCustomer_args:
7703 
  """
7704 
  Attributes:
7705 
   - customer_id
7706 
   - limit
7707 
  """
7708 
 
7709 
  thrift_spec = (
7710 
    None, # 0
7711 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7712 
    (2, TType.I64, 'limit', None, None, ), # 2
7713 
  )
7714 
 
7715 
  def __init__(self, customer_id=None, limit=None,):
7716 
    self.customer_id = customer_id
7717 
    self.limit = limit
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 == 1:
7729 
        if ftype == TType.I64:
7730 
          self.customer_id = iprot.readI64();
7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      elif fid == 2:
7734 
        if ftype == TType.I64:
7735 
          self.limit = iprot.readI64();
7736 
        else:
7737 
          iprot.skip(ftype)
7738 
      else:
7739 
        iprot.skip(ftype)
7740 
      iprot.readFieldEnd()
7741 
    iprot.readStructEnd()
7742 
 
7743 
  def write(self, oprot):
7744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7746 
      return
7747 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7748 
    if self.customer_id is not None:
1382 varun.gupt 7749 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7750 
      oprot.writeI64(self.customer_id)
7751 
      oprot.writeFieldEnd()
3431 rajveer 7752 
    if self.limit is not None:
1382 varun.gupt 7753 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7754 
      oprot.writeI64(self.limit)
7755 
      oprot.writeFieldEnd()
7756 
    oprot.writeFieldStop()
7757 
    oprot.writeStructEnd()
7758 
 
3431 rajveer 7759 
  def validate(self):
7760 
    return
7761 
 
7762 
 
1382 varun.gupt 7763 
  def __repr__(self):
7764 
    L = ['%s=%r' % (key, value)
7765 
      for key, value in self.__dict__.iteritems()]
7766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7767 
 
7768 
  def __eq__(self, other):
7769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7770 
 
7771 
  def __ne__(self, other):
7772 
    return not (self == other)
7773 
 
7774 
class getReturnableOrdersForCustomer_result:
7775 
  """
7776 
  Attributes:
7777 
   - success
7778 
   - ex
7779 
  """
7780 
 
7781 
  thrift_spec = (
7782 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7784 
  )
7785 
 
7786 
  def __init__(self, success=None, ex=None,):
7787 
    self.success = success
7788 
    self.ex = ex
7789 
 
7790 
  def read(self, iprot):
7791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7793 
      return
7794 
    iprot.readStructBegin()
7795 
    while True:
7796 
      (fname, ftype, fid) = iprot.readFieldBegin()
7797 
      if ftype == TType.STOP:
7798 
        break
7799 
      if fid == 0:
7800 
        if ftype == TType.LIST:
7801 
          self.success = []
4133 chandransh 7802 
          (_etype73, _size70) = iprot.readListBegin()
7803 
          for _i74 in xrange(_size70):
7804 
            _elem75 = iprot.readI64();
7805 
            self.success.append(_elem75)
1382 varun.gupt 7806 
          iprot.readListEnd()
7807 
        else:
7808 
          iprot.skip(ftype)
7809 
      elif fid == 1:
7810 
        if ftype == TType.STRUCT:
7811 
          self.ex = TransactionServiceException()
7812 
          self.ex.read(iprot)
7813 
        else:
7814 
          iprot.skip(ftype)
7815 
      else:
7816 
        iprot.skip(ftype)
7817 
      iprot.readFieldEnd()
7818 
    iprot.readStructEnd()
7819 
 
7820 
  def write(self, oprot):
7821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7823 
      return
7824 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7825 
    if self.success is not None:
1382 varun.gupt 7826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7827 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7828 
      for iter76 in self.success:
7829 
        oprot.writeI64(iter76)
1382 varun.gupt 7830 
      oprot.writeListEnd()
7831 
      oprot.writeFieldEnd()
3431 rajveer 7832 
    if self.ex is not None:
1382 varun.gupt 7833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7834 
      self.ex.write(oprot)
7835 
      oprot.writeFieldEnd()
7836 
    oprot.writeFieldStop()
7837 
    oprot.writeStructEnd()
7838 
 
3431 rajveer 7839 
  def validate(self):
7840 
    return
7841 
 
7842 
 
1382 varun.gupt 7843 
  def __repr__(self):
7844 
    L = ['%s=%r' % (key, value)
7845 
      for key, value in self.__dict__.iteritems()]
7846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7847 
 
7848 
  def __eq__(self, other):
7849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7850 
 
7851 
  def __ne__(self, other):
7852 
    return not (self == other)
7853 
 
7854 
class getCancellableOrdersForCustomer_args:
7855 
  """
7856 
  Attributes:
7857 
   - customer_id
7858 
   - limit
7859 
  """
7860 
 
7861 
  thrift_spec = (
7862 
    None, # 0
7863 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7864 
    (2, TType.I64, 'limit', None, None, ), # 2
7865 
  )
7866 
 
7867 
  def __init__(self, customer_id=None, limit=None,):
7868 
    self.customer_id = customer_id
7869 
    self.limit = limit
7870 
 
7871 
  def read(self, iprot):
7872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7874 
      return
7875 
    iprot.readStructBegin()
7876 
    while True:
7877 
      (fname, ftype, fid) = iprot.readFieldBegin()
7878 
      if ftype == TType.STOP:
7879 
        break
7880 
      if fid == 1:
7881 
        if ftype == TType.I64:
7882 
          self.customer_id = iprot.readI64();
7883 
        else:
7884 
          iprot.skip(ftype)
7885 
      elif fid == 2:
7886 
        if ftype == TType.I64:
7887 
          self.limit = iprot.readI64();
7888 
        else:
7889 
          iprot.skip(ftype)
7890 
      else:
7891 
        iprot.skip(ftype)
7892 
      iprot.readFieldEnd()
7893 
    iprot.readStructEnd()
7894 
 
7895 
  def write(self, oprot):
7896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7898 
      return
7899 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7900 
    if self.customer_id is not None:
1382 varun.gupt 7901 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7902 
      oprot.writeI64(self.customer_id)
7903 
      oprot.writeFieldEnd()
3431 rajveer 7904 
    if self.limit is not None:
1382 varun.gupt 7905 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7906 
      oprot.writeI64(self.limit)
7907 
      oprot.writeFieldEnd()
7908 
    oprot.writeFieldStop()
7909 
    oprot.writeStructEnd()
7910 
 
3431 rajveer 7911 
  def validate(self):
7912 
    return
7913 
 
7914 
 
1382 varun.gupt 7915 
  def __repr__(self):
7916 
    L = ['%s=%r' % (key, value)
7917 
      for key, value in self.__dict__.iteritems()]
7918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7919 
 
7920 
  def __eq__(self, other):
7921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7922 
 
7923 
  def __ne__(self, other):
7924 
    return not (self == other)
7925 
 
7926 
class getCancellableOrdersForCustomer_result:
7927 
  """
7928 
  Attributes:
7929 
   - success
7930 
   - ex
7931 
  """
7932 
 
7933 
  thrift_spec = (
7934 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7936 
  )
7937 
 
7938 
  def __init__(self, success=None, ex=None,):
7939 
    self.success = success
7940 
    self.ex = ex
7941 
 
7942 
  def read(self, iprot):
7943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7945 
      return
7946 
    iprot.readStructBegin()
7947 
    while True:
7948 
      (fname, ftype, fid) = iprot.readFieldBegin()
7949 
      if ftype == TType.STOP:
7950 
        break
7951 
      if fid == 0:
7952 
        if ftype == TType.LIST:
7953 
          self.success = []
4133 chandransh 7954 
          (_etype80, _size77) = iprot.readListBegin()
7955 
          for _i81 in xrange(_size77):
7956 
            _elem82 = iprot.readI64();
7957 
            self.success.append(_elem82)
1382 varun.gupt 7958 
          iprot.readListEnd()
7959 
        else:
7960 
          iprot.skip(ftype)
7961 
      elif fid == 1:
7962 
        if ftype == TType.STRUCT:
7963 
          self.ex = TransactionServiceException()
7964 
          self.ex.read(iprot)
7965 
        else:
7966 
          iprot.skip(ftype)
7967 
      else:
7968 
        iprot.skip(ftype)
7969 
      iprot.readFieldEnd()
7970 
    iprot.readStructEnd()
7971 
 
7972 
  def write(self, oprot):
7973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7975 
      return
7976 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7977 
    if self.success is not None:
1382 varun.gupt 7978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7979 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7980 
      for iter83 in self.success:
7981 
        oprot.writeI64(iter83)
1382 varun.gupt 7982 
      oprot.writeListEnd()
7983 
      oprot.writeFieldEnd()
3431 rajveer 7984 
    if self.ex is not None:
1382 varun.gupt 7985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7986 
      self.ex.write(oprot)
7987 
      oprot.writeFieldEnd()
7988 
    oprot.writeFieldStop()
7989 
    oprot.writeStructEnd()
7990 
 
3431 rajveer 7991 
  def validate(self):
7992 
    return
7993 
 
7994 
 
1382 varun.gupt 7995 
  def __repr__(self):
7996 
    L = ['%s=%r' % (key, value)
7997 
      for key, value in self.__dict__.iteritems()]
7998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7999 
 
8000 
  def __eq__(self, other):
8001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8002 
 
8003 
  def __ne__(self, other):
8004 
    return not (self == other)
8005 
 
483 rajveer 8006 
class changeOrderStatus_args:
94 ashish 8007 
  """
8008 
  Attributes:
483 rajveer 8009 
   - orderId
8010 
   - status
8011 
   - description
94 ashish 8012 
  """
8013 
 
8014 
  thrift_spec = (
8015 
    None, # 0
483 rajveer 8016 
    (1, TType.I64, 'orderId', None, None, ), # 1
8017 
    (2, TType.I32, 'status', None, None, ), # 2
8018 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8019 
  )
8020 
 
483 rajveer 8021 
  def __init__(self, orderId=None, status=None, description=None,):
8022 
    self.orderId = orderId
8023 
    self.status = status
8024 
    self.description = description
94 ashish 8025 
 
8026 
  def read(self, iprot):
8027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8029 
      return
8030 
    iprot.readStructBegin()
8031 
    while True:
8032 
      (fname, ftype, fid) = iprot.readFieldBegin()
8033 
      if ftype == TType.STOP:
8034 
        break
8035 
      if fid == 1:
8036 
        if ftype == TType.I64:
483 rajveer 8037 
          self.orderId = iprot.readI64();
94 ashish 8038 
        else:
8039 
          iprot.skip(ftype)
8040 
      elif fid == 2:
483 rajveer 8041 
        if ftype == TType.I32:
8042 
          self.status = iprot.readI32();
94 ashish 8043 
        else:
8044 
          iprot.skip(ftype)
483 rajveer 8045 
      elif fid == 3:
8046 
        if ftype == TType.STRING:
8047 
          self.description = iprot.readString();
8048 
        else:
8049 
          iprot.skip(ftype)
94 ashish 8050 
      else:
8051 
        iprot.skip(ftype)
8052 
      iprot.readFieldEnd()
8053 
    iprot.readStructEnd()
8054 
 
8055 
  def write(self, oprot):
8056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8058 
      return
483 rajveer 8059 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8060 
    if self.orderId is not None:
483 rajveer 8061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8062 
      oprot.writeI64(self.orderId)
94 ashish 8063 
      oprot.writeFieldEnd()
3431 rajveer 8064 
    if self.status is not None:
483 rajveer 8065 
      oprot.writeFieldBegin('status', TType.I32, 2)
8066 
      oprot.writeI32(self.status)
94 ashish 8067 
      oprot.writeFieldEnd()
3431 rajveer 8068 
    if self.description is not None:
483 rajveer 8069 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8070 
      oprot.writeString(self.description)
8071 
      oprot.writeFieldEnd()
94 ashish 8072 
    oprot.writeFieldStop()
8073 
    oprot.writeStructEnd()
8074 
 
3431 rajveer 8075 
  def validate(self):
8076 
    return
8077 
 
8078 
 
94 ashish 8079 
  def __repr__(self):
8080 
    L = ['%s=%r' % (key, value)
8081 
      for key, value in self.__dict__.iteritems()]
8082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8083 
 
8084 
  def __eq__(self, other):
8085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8086 
 
8087 
  def __ne__(self, other):
8088 
    return not (self == other)
8089 
 
483 rajveer 8090 
class changeOrderStatus_result:
94 ashish 8091 
  """
8092 
  Attributes:
8093 
   - success
8094 
   - ex
8095 
  """
8096 
 
8097 
  thrift_spec = (
8098 
    (0, TType.BOOL, 'success', None, None, ), # 0
8099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8100 
  )
8101 
 
8102 
  def __init__(self, success=None, ex=None,):
8103 
    self.success = success
8104 
    self.ex = ex
8105 
 
8106 
  def read(self, iprot):
8107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8109 
      return
8110 
    iprot.readStructBegin()
8111 
    while True:
8112 
      (fname, ftype, fid) = iprot.readFieldBegin()
8113 
      if ftype == TType.STOP:
8114 
        break
8115 
      if fid == 0:
8116 
        if ftype == TType.BOOL:
8117 
          self.success = iprot.readBool();
8118 
        else:
8119 
          iprot.skip(ftype)
8120 
      elif fid == 1:
8121 
        if ftype == TType.STRUCT:
8122 
          self.ex = TransactionServiceException()
8123 
          self.ex.read(iprot)
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      else:
8127 
        iprot.skip(ftype)
8128 
      iprot.readFieldEnd()
8129 
    iprot.readStructEnd()
8130 
 
8131 
  def write(self, oprot):
8132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8134 
      return
483 rajveer 8135 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8136 
    if self.success is not None:
94 ashish 8137 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8138 
      oprot.writeBool(self.success)
8139 
      oprot.writeFieldEnd()
3431 rajveer 8140 
    if self.ex is not None:
94 ashish 8141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8142 
      self.ex.write(oprot)
8143 
      oprot.writeFieldEnd()
8144 
    oprot.writeFieldStop()
8145 
    oprot.writeStructEnd()
8146 
 
3431 rajveer 8147 
  def validate(self):
8148 
    return
8149 
 
8150 
 
94 ashish 8151 
  def __repr__(self):
8152 
    L = ['%s=%r' % (key, value)
8153 
      for key, value in self.__dict__.iteritems()]
8154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8155 
 
8156 
  def __eq__(self, other):
8157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8158 
 
8159 
  def __ne__(self, other):
8160 
    return not (self == other)
8161 
 
3064 chandransh 8162 
class getOrdersForTransaction_args:
494 rajveer 8163 
  """
8164 
  Attributes:
3064 chandransh 8165 
   - transactionId
8166 
   - customerId
494 rajveer 8167 
  """
8168 
 
8169 
  thrift_spec = (
8170 
    None, # 0
3064 chandransh 8171 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8172 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8173 
  )
8174 
 
3064 chandransh 8175 
  def __init__(self, transactionId=None, customerId=None,):
8176 
    self.transactionId = transactionId
8177 
    self.customerId = customerId
494 rajveer 8178 
 
8179 
  def read(self, iprot):
8180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8182 
      return
8183 
    iprot.readStructBegin()
8184 
    while True:
8185 
      (fname, ftype, fid) = iprot.readFieldBegin()
8186 
      if ftype == TType.STOP:
8187 
        break
8188 
      if fid == 1:
8189 
        if ftype == TType.I64:
3064 chandransh 8190 
          self.transactionId = iprot.readI64();
494 rajveer 8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      elif fid == 2:
3064 chandransh 8194 
        if ftype == TType.I64:
8195 
          self.customerId = iprot.readI64();
494 rajveer 8196 
        else:
8197 
          iprot.skip(ftype)
8198 
      else:
8199 
        iprot.skip(ftype)
8200 
      iprot.readFieldEnd()
8201 
    iprot.readStructEnd()
8202 
 
8203 
  def write(self, oprot):
8204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8206 
      return
3064 chandransh 8207 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8208 
    if self.transactionId is not None:
3064 chandransh 8209 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8210 
      oprot.writeI64(self.transactionId)
494 rajveer 8211 
      oprot.writeFieldEnd()
3431 rajveer 8212 
    if self.customerId is not None:
3064 chandransh 8213 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8214 
      oprot.writeI64(self.customerId)
494 rajveer 8215 
      oprot.writeFieldEnd()
8216 
    oprot.writeFieldStop()
8217 
    oprot.writeStructEnd()
8218 
 
3431 rajveer 8219 
  def validate(self):
8220 
    return
8221 
 
8222 
 
494 rajveer 8223 
  def __repr__(self):
8224 
    L = ['%s=%r' % (key, value)
8225 
      for key, value in self.__dict__.iteritems()]
8226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8227 
 
8228 
  def __eq__(self, other):
8229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8230 
 
8231 
  def __ne__(self, other):
8232 
    return not (self == other)
8233 
 
3064 chandransh 8234 
class getOrdersForTransaction_result:
494 rajveer 8235 
  """
8236 
  Attributes:
8237 
   - success
8238 
   - ex
8239 
  """
8240 
 
8241 
  thrift_spec = (
3064 chandransh 8242 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8244 
  )
8245 
 
8246 
  def __init__(self, success=None, ex=None,):
8247 
    self.success = success
8248 
    self.ex = ex
8249 
 
8250 
  def read(self, iprot):
8251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8253 
      return
8254 
    iprot.readStructBegin()
8255 
    while True:
8256 
      (fname, ftype, fid) = iprot.readFieldBegin()
8257 
      if ftype == TType.STOP:
8258 
        break
8259 
      if fid == 0:
3064 chandransh 8260 
        if ftype == TType.LIST:
8261 
          self.success = []
4133 chandransh 8262 
          (_etype87, _size84) = iprot.readListBegin()
8263 
          for _i88 in xrange(_size84):
8264 
            _elem89 = Order()
8265 
            _elem89.read(iprot)
8266 
            self.success.append(_elem89)
3064 chandransh 8267 
          iprot.readListEnd()
494 rajveer 8268 
        else:
8269 
          iprot.skip(ftype)
8270 
      elif fid == 1:
8271 
        if ftype == TType.STRUCT:
8272 
          self.ex = TransactionServiceException()
8273 
          self.ex.read(iprot)
8274 
        else:
8275 
          iprot.skip(ftype)
8276 
      else:
8277 
        iprot.skip(ftype)
8278 
      iprot.readFieldEnd()
8279 
    iprot.readStructEnd()
8280 
 
8281 
  def write(self, oprot):
8282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8284 
      return
3064 chandransh 8285 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8286 
    if self.success is not None:
3064 chandransh 8287 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8288 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8289 
      for iter90 in self.success:
8290 
        iter90.write(oprot)
3064 chandransh 8291 
      oprot.writeListEnd()
494 rajveer 8292 
      oprot.writeFieldEnd()
3431 rajveer 8293 
    if self.ex is not None:
494 rajveer 8294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8295 
      self.ex.write(oprot)
8296 
      oprot.writeFieldEnd()
8297 
    oprot.writeFieldStop()
8298 
    oprot.writeStructEnd()
8299 
 
3431 rajveer 8300 
  def validate(self):
8301 
    return
8302 
 
8303 
 
494 rajveer 8304 
  def __repr__(self):
8305 
    L = ['%s=%r' % (key, value)
8306 
      for key, value in self.__dict__.iteritems()]
8307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8308 
 
8309 
  def __eq__(self, other):
8310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8311 
 
8312 
  def __ne__(self, other):
8313 
    return not (self == other)
8314 
 
3064 chandransh 8315 
class getOrdersForCustomer_args:
1149 chandransh 8316 
  """
8317 
  Attributes:
3064 chandransh 8318 
   - customerId
8319 
   - from_date
8320 
   - to_date
8321 
   - statuses
1149 chandransh 8322 
  """
8323 
 
8324 
  thrift_spec = (
8325 
    None, # 0
3064 chandransh 8326 
    (1, TType.I64, 'customerId', None, None, ), # 1
8327 
    (2, TType.I64, 'from_date', None, None, ), # 2
8328 
    (3, TType.I64, 'to_date', None, None, ), # 3
8329 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8330 
  )
8331 
 
3064 chandransh 8332 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8333 
    self.customerId = customerId
8334 
    self.from_date = from_date
8335 
    self.to_date = to_date
8336 
    self.statuses = statuses
1149 chandransh 8337 
 
8338 
  def read(self, iprot):
8339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8341 
      return
8342 
    iprot.readStructBegin()
8343 
    while True:
8344 
      (fname, ftype, fid) = iprot.readFieldBegin()
8345 
      if ftype == TType.STOP:
8346 
        break
8347 
      if fid == 1:
8348 
        if ftype == TType.I64:
3064 chandransh 8349 
          self.customerId = iprot.readI64();
1149 chandransh 8350 
        else:
8351 
          iprot.skip(ftype)
8352 
      elif fid == 2:
8353 
        if ftype == TType.I64:
3064 chandransh 8354 
          self.from_date = iprot.readI64();
1149 chandransh 8355 
        else:
8356 
          iprot.skip(ftype)
2783 chandransh 8357 
      elif fid == 3:
8358 
        if ftype == TType.I64:
3064 chandransh 8359 
          self.to_date = iprot.readI64();
2783 chandransh 8360 
        else:
8361 
          iprot.skip(ftype)
8362 
      elif fid == 4:
3064 chandransh 8363 
        if ftype == TType.LIST:
8364 
          self.statuses = []
4133 chandransh 8365 
          (_etype94, _size91) = iprot.readListBegin()
8366 
          for _i95 in xrange(_size91):
8367 
            _elem96 = iprot.readI32();
8368 
            self.statuses.append(_elem96)
3064 chandransh 8369 
          iprot.readListEnd()
2783 chandransh 8370 
        else:
8371 
          iprot.skip(ftype)
1149 chandransh 8372 
      else:
8373 
        iprot.skip(ftype)
8374 
      iprot.readFieldEnd()
8375 
    iprot.readStructEnd()
8376 
 
8377 
  def write(self, oprot):
8378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8380 
      return
3064 chandransh 8381 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8382 
    if self.customerId is not None:
3064 chandransh 8383 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8384 
      oprot.writeI64(self.customerId)
1149 chandransh 8385 
      oprot.writeFieldEnd()
3431 rajveer 8386 
    if self.from_date is not None:
3064 chandransh 8387 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8388 
      oprot.writeI64(self.from_date)
1149 chandransh 8389 
      oprot.writeFieldEnd()
3431 rajveer 8390 
    if self.to_date is not None:
3064 chandransh 8391 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8392 
      oprot.writeI64(self.to_date)
2783 chandransh 8393 
      oprot.writeFieldEnd()
3431 rajveer 8394 
    if self.statuses is not None:
3064 chandransh 8395 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8396 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8397 
      for iter97 in self.statuses:
8398 
        oprot.writeI32(iter97)
3064 chandransh 8399 
      oprot.writeListEnd()
2783 chandransh 8400 
      oprot.writeFieldEnd()
1149 chandransh 8401 
    oprot.writeFieldStop()
8402 
    oprot.writeStructEnd()
8403 
 
3431 rajveer 8404 
  def validate(self):
8405 
    return
8406 
 
8407 
 
1149 chandransh 8408 
  def __repr__(self):
8409 
    L = ['%s=%r' % (key, value)
8410 
      for key, value in self.__dict__.iteritems()]
8411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8412 
 
8413 
  def __eq__(self, other):
8414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8415 
 
8416 
  def __ne__(self, other):
8417 
    return not (self == other)
8418 
 
3064 chandransh 8419 
class getOrdersForCustomer_result:
1149 chandransh 8420 
  """
8421 
  Attributes:
8422 
   - success
8423 
   - ex
8424 
  """
8425 
 
8426 
  thrift_spec = (
3064 chandransh 8427 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8429 
  )
8430 
 
8431 
  def __init__(self, success=None, ex=None,):
8432 
    self.success = success
8433 
    self.ex = ex
8434 
 
8435 
  def read(self, iprot):
8436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8438 
      return
8439 
    iprot.readStructBegin()
8440 
    while True:
8441 
      (fname, ftype, fid) = iprot.readFieldBegin()
8442 
      if ftype == TType.STOP:
8443 
        break
8444 
      if fid == 0:
3064 chandransh 8445 
        if ftype == TType.LIST:
8446 
          self.success = []
4133 chandransh 8447 
          (_etype101, _size98) = iprot.readListBegin()
8448 
          for _i102 in xrange(_size98):
8449 
            _elem103 = Order()
8450 
            _elem103.read(iprot)
8451 
            self.success.append(_elem103)
3064 chandransh 8452 
          iprot.readListEnd()
1149 chandransh 8453 
        else:
8454 
          iprot.skip(ftype)
8455 
      elif fid == 1:
8456 
        if ftype == TType.STRUCT:
8457 
          self.ex = TransactionServiceException()
8458 
          self.ex.read(iprot)
8459 
        else:
8460 
          iprot.skip(ftype)
8461 
      else:
8462 
        iprot.skip(ftype)
8463 
      iprot.readFieldEnd()
8464 
    iprot.readStructEnd()
8465 
 
8466 
  def write(self, oprot):
8467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8469 
      return
3064 chandransh 8470 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8471 
    if self.success is not None:
3064 chandransh 8472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8474 
      for iter104 in self.success:
8475 
        iter104.write(oprot)
3064 chandransh 8476 
      oprot.writeListEnd()
1149 chandransh 8477 
      oprot.writeFieldEnd()
3431 rajveer 8478 
    if self.ex is not None:
1149 chandransh 8479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8480 
      self.ex.write(oprot)
8481 
      oprot.writeFieldEnd()
8482 
    oprot.writeFieldStop()
8483 
    oprot.writeStructEnd()
8484 
 
3431 rajveer 8485 
  def validate(self):
8486 
    return
8487 
 
8488 
 
1149 chandransh 8489 
  def __repr__(self):
8490 
    L = ['%s=%r' % (key, value)
8491 
      for key, value in self.__dict__.iteritems()]
8492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8493 
 
8494 
  def __eq__(self, other):
8495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8496 
 
8497 
  def __ne__(self, other):
8498 
    return not (self == other)
8499 
 
3064 chandransh 8500 
class createOrder_args:
921 rajveer 8501 
  """
8502 
  Attributes:
3064 chandransh 8503 
   - order
921 rajveer 8504 
  """
8505 
 
8506 
  thrift_spec = (
8507 
    None, # 0
3064 chandransh 8508 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8509 
  )
8510 
 
3064 chandransh 8511 
  def __init__(self, order=None,):
8512 
    self.order = order
921 rajveer 8513 
 
8514 
  def read(self, iprot):
8515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8517 
      return
8518 
    iprot.readStructBegin()
8519 
    while True:
8520 
      (fname, ftype, fid) = iprot.readFieldBegin()
8521 
      if ftype == TType.STOP:
8522 
        break
8523 
      if fid == 1:
3064 chandransh 8524 
        if ftype == TType.STRUCT:
8525 
          self.order = Order()
8526 
          self.order.read(iprot)
921 rajveer 8527 
        else:
8528 
          iprot.skip(ftype)
8529 
      else:
8530 
        iprot.skip(ftype)
8531 
      iprot.readFieldEnd()
8532 
    iprot.readStructEnd()
8533 
 
8534 
  def write(self, oprot):
8535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8537 
      return
3064 chandransh 8538 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8539 
    if self.order is not None:
3064 chandransh 8540 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8541 
      self.order.write(oprot)
921 rajveer 8542 
      oprot.writeFieldEnd()
8543 
    oprot.writeFieldStop()
8544 
    oprot.writeStructEnd()
8545 
 
3431 rajveer 8546 
  def validate(self):
8547 
    return
8548 
 
8549 
 
921 rajveer 8550 
  def __repr__(self):
8551 
    L = ['%s=%r' % (key, value)
8552 
      for key, value in self.__dict__.iteritems()]
8553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8554 
 
8555 
  def __eq__(self, other):
8556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8557 
 
8558 
  def __ne__(self, other):
8559 
    return not (self == other)
8560 
 
3064 chandransh 8561 
class createOrder_result:
921 rajveer 8562 
  """
8563 
  Attributes:
8564 
   - success
8565 
   - ex
8566 
  """
8567 
 
8568 
  thrift_spec = (
3064 chandransh 8569 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8571 
  )
8572 
 
8573 
  def __init__(self, success=None, ex=None,):
8574 
    self.success = success
8575 
    self.ex = ex
8576 
 
8577 
  def read(self, iprot):
8578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8580 
      return
8581 
    iprot.readStructBegin()
8582 
    while True:
8583 
      (fname, ftype, fid) = iprot.readFieldBegin()
8584 
      if ftype == TType.STOP:
8585 
        break
8586 
      if fid == 0:
3064 chandransh 8587 
        if ftype == TType.I64:
8588 
          self.success = iprot.readI64();
921 rajveer 8589 
        else:
8590 
          iprot.skip(ftype)
8591 
      elif fid == 1:
8592 
        if ftype == TType.STRUCT:
8593 
          self.ex = TransactionServiceException()
8594 
          self.ex.read(iprot)
8595 
        else:
8596 
          iprot.skip(ftype)
8597 
      else:
8598 
        iprot.skip(ftype)
8599 
      iprot.readFieldEnd()
8600 
    iprot.readStructEnd()
8601 
 
8602 
  def write(self, oprot):
8603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8605 
      return
3064 chandransh 8606 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8607 
    if self.success is not None:
3064 chandransh 8608 
      oprot.writeFieldBegin('success', TType.I64, 0)
8609 
      oprot.writeI64(self.success)
921 rajveer 8610 
      oprot.writeFieldEnd()
3431 rajveer 8611 
    if self.ex is not None:
921 rajveer 8612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8613 
      self.ex.write(oprot)
8614 
      oprot.writeFieldEnd()
8615 
    oprot.writeFieldStop()
8616 
    oprot.writeStructEnd()
8617 
 
3431 rajveer 8618 
  def validate(self):
8619 
    return
8620 
 
8621 
 
921 rajveer 8622 
  def __repr__(self):
8623 
    L = ['%s=%r' % (key, value)
8624 
      for key, value in self.__dict__.iteritems()]
8625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8626 
 
8627 
  def __eq__(self, other):
8628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8629 
 
8630 
  def __ne__(self, other):
8631 
    return not (self == other)
8632 
 
3064 chandransh 8633 
class getOrder_args:
921 rajveer 8634 
  """
8635 
  Attributes:
3064 chandransh 8636 
   - id
921 rajveer 8637 
  """
8638 
 
8639 
  thrift_spec = (
8640 
    None, # 0
3064 chandransh 8641 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8642 
  )
8643 
 
3064 chandransh 8644 
  def __init__(self, id=None,):
8645 
    self.id = id
921 rajveer 8646 
 
8647 
  def read(self, iprot):
8648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8650 
      return
8651 
    iprot.readStructBegin()
8652 
    while True:
8653 
      (fname, ftype, fid) = iprot.readFieldBegin()
8654 
      if ftype == TType.STOP:
8655 
        break
8656 
      if fid == 1:
8657 
        if ftype == TType.I64:
3064 chandransh 8658 
          self.id = iprot.readI64();
921 rajveer 8659 
        else:
8660 
          iprot.skip(ftype)
8661 
      else:
8662 
        iprot.skip(ftype)
8663 
      iprot.readFieldEnd()
8664 
    iprot.readStructEnd()
8665 
 
8666 
  def write(self, oprot):
8667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8669 
      return
3064 chandransh 8670 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8671 
    if self.id is not None:
3064 chandransh 8672 
      oprot.writeFieldBegin('id', TType.I64, 1)
8673 
      oprot.writeI64(self.id)
921 rajveer 8674 
      oprot.writeFieldEnd()
8675 
    oprot.writeFieldStop()
8676 
    oprot.writeStructEnd()
8677 
 
3431 rajveer 8678 
  def validate(self):
8679 
    return
8680 
 
8681 
 
921 rajveer 8682 
  def __repr__(self):
8683 
    L = ['%s=%r' % (key, value)
8684 
      for key, value in self.__dict__.iteritems()]
8685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8686 
 
8687 
  def __eq__(self, other):
8688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8689 
 
8690 
  def __ne__(self, other):
8691 
    return not (self == other)
8692 
 
3064 chandransh 8693 
class getOrder_result:
921 rajveer 8694 
  """
8695 
  Attributes:
8696 
   - success
8697 
   - ex
8698 
  """
8699 
 
8700 
  thrift_spec = (
3064 chandransh 8701 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8703 
  )
8704 
 
8705 
  def __init__(self, success=None, ex=None,):
8706 
    self.success = success
8707 
    self.ex = ex
8708 
 
8709 
  def read(self, iprot):
8710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8712 
      return
8713 
    iprot.readStructBegin()
8714 
    while True:
8715 
      (fname, ftype, fid) = iprot.readFieldBegin()
8716 
      if ftype == TType.STOP:
8717 
        break
8718 
      if fid == 0:
3064 chandransh 8719 
        if ftype == TType.STRUCT:
8720 
          self.success = Order()
8721 
          self.success.read(iprot)
921 rajveer 8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      elif fid == 1:
8725 
        if ftype == TType.STRUCT:
8726 
          self.ex = TransactionServiceException()
8727 
          self.ex.read(iprot)
8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      else:
8731 
        iprot.skip(ftype)
8732 
      iprot.readFieldEnd()
8733 
    iprot.readStructEnd()
8734 
 
8735 
  def write(self, oprot):
8736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8738 
      return
3064 chandransh 8739 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8740 
    if self.success is not None:
3064 chandransh 8741 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8742 
      self.success.write(oprot)
921 rajveer 8743 
      oprot.writeFieldEnd()
3431 rajveer 8744 
    if self.ex is not None:
921 rajveer 8745 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8746 
      self.ex.write(oprot)
8747 
      oprot.writeFieldEnd()
8748 
    oprot.writeFieldStop()
8749 
    oprot.writeStructEnd()
8750 
 
3431 rajveer 8751 
  def validate(self):
8752 
    return
8753 
 
8754 
 
921 rajveer 8755 
  def __repr__(self):
8756 
    L = ['%s=%r' % (key, value)
8757 
      for key, value in self.__dict__.iteritems()]
8758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8759 
 
8760 
  def __eq__(self, other):
8761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8762 
 
8763 
  def __ne__(self, other):
8764 
    return not (self == other)
8765 
 
3064 chandransh 8766 
class getLineItemsForOrder_args:
94 ashish 8767 
  """
8768 
  Attributes:
3064 chandransh 8769 
   - orderId
94 ashish 8770 
  """
8771 
 
8772 
  thrift_spec = (
8773 
    None, # 0
3064 chandransh 8774 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8775 
  )
8776 
 
3064 chandransh 8777 
  def __init__(self, orderId=None,):
8778 
    self.orderId = orderId
94 ashish 8779 
 
8780 
  def read(self, iprot):
8781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8783 
      return
8784 
    iprot.readStructBegin()
8785 
    while True:
8786 
      (fname, ftype, fid) = iprot.readFieldBegin()
8787 
      if ftype == TType.STOP:
8788 
        break
8789 
      if fid == 1:
8790 
        if ftype == TType.I64:
3064 chandransh 8791 
          self.orderId = iprot.readI64();
94 ashish 8792 
        else:
8793 
          iprot.skip(ftype)
8794 
      else:
8795 
        iprot.skip(ftype)
8796 
      iprot.readFieldEnd()
8797 
    iprot.readStructEnd()
8798 
 
8799 
  def write(self, oprot):
8800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8802 
      return
3064 chandransh 8803 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8804 
    if self.orderId is not None:
3064 chandransh 8805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8806 
      oprot.writeI64(self.orderId)
94 ashish 8807 
      oprot.writeFieldEnd()
8808 
    oprot.writeFieldStop()
8809 
    oprot.writeStructEnd()
8810 
 
3431 rajveer 8811 
  def validate(self):
8812 
    return
8813 
 
8814 
 
94 ashish 8815 
  def __repr__(self):
8816 
    L = ['%s=%r' % (key, value)
8817 
      for key, value in self.__dict__.iteritems()]
8818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8819 
 
8820 
  def __eq__(self, other):
8821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8822 
 
8823 
  def __ne__(self, other):
8824 
    return not (self == other)
8825 
 
3064 chandransh 8826 
class getLineItemsForOrder_result:
94 ashish 8827 
  """
8828 
  Attributes:
8829 
   - success
8830 
   - ex
8831 
  """
8832 
 
8833 
  thrift_spec = (
3064 chandransh 8834 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8836 
  )
8837 
 
8838 
  def __init__(self, success=None, ex=None,):
8839 
    self.success = success
8840 
    self.ex = ex
8841 
 
8842 
  def read(self, iprot):
8843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8845 
      return
8846 
    iprot.readStructBegin()
8847 
    while True:
8848 
      (fname, ftype, fid) = iprot.readFieldBegin()
8849 
      if ftype == TType.STOP:
8850 
        break
8851 
      if fid == 0:
483 rajveer 8852 
        if ftype == TType.LIST:
8853 
          self.success = []
4133 chandransh 8854 
          (_etype108, _size105) = iprot.readListBegin()
8855 
          for _i109 in xrange(_size105):
8856 
            _elem110 = LineItem()
8857 
            _elem110.read(iprot)
8858 
            self.success.append(_elem110)
483 rajveer 8859 
          iprot.readListEnd()
94 ashish 8860 
        else:
8861 
          iprot.skip(ftype)
8862 
      elif fid == 1:
8863 
        if ftype == TType.STRUCT:
8864 
          self.ex = TransactionServiceException()
8865 
          self.ex.read(iprot)
8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      else:
8869 
        iprot.skip(ftype)
8870 
      iprot.readFieldEnd()
8871 
    iprot.readStructEnd()
8872 
 
8873 
  def write(self, oprot):
8874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8876 
      return
3064 chandransh 8877 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8878 
    if self.success is not None:
483 rajveer 8879 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8880 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8881 
      for iter111 in self.success:
8882 
        iter111.write(oprot)
483 rajveer 8883 
      oprot.writeListEnd()
94 ashish 8884 
      oprot.writeFieldEnd()
3431 rajveer 8885 
    if self.ex is not None:
94 ashish 8886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8887 
      self.ex.write(oprot)
8888 
      oprot.writeFieldEnd()
8889 
    oprot.writeFieldStop()
8890 
    oprot.writeStructEnd()
8891 
 
3431 rajveer 8892 
  def validate(self):
8893 
    return
8894 
 
8895 
 
94 ashish 8896 
  def __repr__(self):
8897 
    L = ['%s=%r' % (key, value)
8898 
      for key, value in self.__dict__.iteritems()]
8899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8900 
 
8901 
  def __eq__(self, other):
8902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8903 
 
8904 
  def __ne__(self, other):
8905 
    return not (self == other)
8906 
 
3064 chandransh 8907 
class getOrderForCustomer_args:
94 ashish 8908 
  """
8909 
  Attributes:
3064 chandransh 8910 
   - orderId
483 rajveer 8911 
   - customerId
94 ashish 8912 
  """
8913 
 
8914 
  thrift_spec = (
8915 
    None, # 0
3064 chandransh 8916 
    (1, TType.I64, 'orderId', None, None, ), # 1
8917 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8918 
  )
8919 
 
3064 chandransh 8920 
  def __init__(self, orderId=None, customerId=None,):
8921 
    self.orderId = orderId
483 rajveer 8922 
    self.customerId = customerId
94 ashish 8923 
 
8924 
  def read(self, iprot):
8925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8927 
      return
8928 
    iprot.readStructBegin()
8929 
    while True:
8930 
      (fname, ftype, fid) = iprot.readFieldBegin()
8931 
      if ftype == TType.STOP:
8932 
        break
8933 
      if fid == 1:
8934 
        if ftype == TType.I64:
3064 chandransh 8935 
          self.orderId = iprot.readI64();
94 ashish 8936 
        else:
8937 
          iprot.skip(ftype)
8938 
      elif fid == 2:
8939 
        if ftype == TType.I64:
3064 chandransh 8940 
          self.customerId = iprot.readI64();
94 ashish 8941 
        else:
8942 
          iprot.skip(ftype)
8943 
      else:
8944 
        iprot.skip(ftype)
8945 
      iprot.readFieldEnd()
8946 
    iprot.readStructEnd()
8947 
 
8948 
  def write(self, oprot):
8949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8951 
      return
3064 chandransh 8952 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8953 
    if self.orderId is not None:
3064 chandransh 8954 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8955 
      oprot.writeI64(self.orderId)
8956 
      oprot.writeFieldEnd()
3431 rajveer 8957 
    if self.customerId is not None:
3064 chandransh 8958 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8959 
      oprot.writeI64(self.customerId)
94 ashish 8960 
      oprot.writeFieldEnd()
8961 
    oprot.writeFieldStop()
8962 
    oprot.writeStructEnd()
8963 
 
3431 rajveer 8964 
  def validate(self):
8965 
    return
8966 
 
8967 
 
94 ashish 8968 
  def __repr__(self):
8969 
    L = ['%s=%r' % (key, value)
8970 
      for key, value in self.__dict__.iteritems()]
8971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8972 
 
8973 
  def __eq__(self, other):
8974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8975 
 
8976 
  def __ne__(self, other):
8977 
    return not (self == other)
8978 
 
3064 chandransh 8979 
class getOrderForCustomer_result:
94 ashish 8980 
  """
8981 
  Attributes:
8982 
   - success
8983 
   - ex
8984 
  """
8985 
 
8986 
  thrift_spec = (
3064 chandransh 8987 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8989 
  )
8990 
 
8991 
  def __init__(self, success=None, ex=None,):
8992 
    self.success = success
8993 
    self.ex = ex
8994 
 
8995 
  def read(self, iprot):
8996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8998 
      return
8999 
    iprot.readStructBegin()
9000 
    while True:
9001 
      (fname, ftype, fid) = iprot.readFieldBegin()
9002 
      if ftype == TType.STOP:
9003 
        break
9004 
      if fid == 0:
3064 chandransh 9005 
        if ftype == TType.STRUCT:
9006 
          self.success = Order()
9007 
          self.success.read(iprot)
94 ashish 9008 
        else:
9009 
          iprot.skip(ftype)
9010 
      elif fid == 1:
9011 
        if ftype == TType.STRUCT:
9012 
          self.ex = TransactionServiceException()
9013 
          self.ex.read(iprot)
9014 
        else:
9015 
          iprot.skip(ftype)
9016 
      else:
9017 
        iprot.skip(ftype)
9018 
      iprot.readFieldEnd()
9019 
    iprot.readStructEnd()
9020 
 
9021 
  def write(self, oprot):
9022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9024 
      return
3064 chandransh 9025 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9026 
    if self.success is not None:
3064 chandransh 9027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9028 
      self.success.write(oprot)
94 ashish 9029 
      oprot.writeFieldEnd()
3431 rajveer 9030 
    if self.ex is not None:
94 ashish 9031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9032 
      self.ex.write(oprot)
9033 
      oprot.writeFieldEnd()
9034 
    oprot.writeFieldStop()
9035 
    oprot.writeStructEnd()
9036 
 
3431 rajveer 9037 
  def validate(self):
9038 
    return
9039 
 
9040 
 
94 ashish 9041 
  def __repr__(self):
9042 
    L = ['%s=%r' % (key, value)
9043 
      for key, value in self.__dict__.iteritems()]
9044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9045 
 
9046 
  def __eq__(self, other):
9047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9048 
 
9049 
  def __ne__(self, other):
9050 
    return not (self == other)
9051 
 
3064 chandransh 9052 
class getAlerts_args:
94 ashish 9053 
  """
9054 
  Attributes:
4394 rajveer 9055 
   - type
4444 rajveer 9056 
   - warehouseId
4394 rajveer 9057 
   - status
9058 
   - timestamp
94 ashish 9059 
  """
9060 
 
9061 
  thrift_spec = (
9062 
    None, # 0
4394 rajveer 9063 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9064 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9065 
    (3, TType.I64, 'status', None, None, ), # 3
9066 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9067 
  )
9068 
 
4444 rajveer 9069 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9070 
    self.type = type
4444 rajveer 9071 
    self.warehouseId = warehouseId
4394 rajveer 9072 
    self.status = status
9073 
    self.timestamp = timestamp
94 ashish 9074 
 
9075 
  def read(self, iprot):
9076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9078 
      return
9079 
    iprot.readStructBegin()
9080 
    while True:
9081 
      (fname, ftype, fid) = iprot.readFieldBegin()
9082 
      if ftype == TType.STOP:
9083 
        break
9084 
      if fid == 1:
3064 chandransh 9085 
        if ftype == TType.I64:
4394 rajveer 9086 
          self.type = iprot.readI64();
94 ashish 9087 
        else:
9088 
          iprot.skip(ftype)
3064 chandransh 9089 
      elif fid == 2:
4394 rajveer 9090 
        if ftype == TType.I64:
4444 rajveer 9091 
          self.warehouseId = iprot.readI64();
3064 chandransh 9092 
        else:
9093 
          iprot.skip(ftype)
4394 rajveer 9094 
      elif fid == 3:
9095 
        if ftype == TType.I64:
4444 rajveer 9096 
          self.status = iprot.readI64();
9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      elif fid == 4:
9100 
        if ftype == TType.I64:
4394 rajveer 9101 
          self.timestamp = iprot.readI64();
9102 
        else:
9103 
          iprot.skip(ftype)
94 ashish 9104 
      else:
9105 
        iprot.skip(ftype)
9106 
      iprot.readFieldEnd()
9107 
    iprot.readStructEnd()
9108 
 
9109 
  def write(self, oprot):
9110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9112 
      return
3064 chandransh 9113 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9114 
    if self.type is not None:
9115 
      oprot.writeFieldBegin('type', TType.I64, 1)
9116 
      oprot.writeI64(self.type)
94 ashish 9117 
      oprot.writeFieldEnd()
4444 rajveer 9118 
    if self.warehouseId is not None:
9119 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9120 
      oprot.writeI64(self.warehouseId)
9121 
      oprot.writeFieldEnd()
4394 rajveer 9122 
    if self.status is not None:
4444 rajveer 9123 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9124 
      oprot.writeI64(self.status)
3064 chandransh 9125 
      oprot.writeFieldEnd()
4394 rajveer 9126 
    if self.timestamp is not None:
4444 rajveer 9127 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9128 
      oprot.writeI64(self.timestamp)
9129 
      oprot.writeFieldEnd()
94 ashish 9130 
    oprot.writeFieldStop()
9131 
    oprot.writeStructEnd()
9132 
 
3431 rajveer 9133 
  def validate(self):
9134 
    return
9135 
 
9136 
 
94 ashish 9137 
  def __repr__(self):
9138 
    L = ['%s=%r' % (key, value)
9139 
      for key, value in self.__dict__.iteritems()]
9140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9141 
 
9142 
  def __eq__(self, other):
9143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9144 
 
9145 
  def __ne__(self, other):
9146 
    return not (self == other)
9147 
 
3064 chandransh 9148 
class getAlerts_result:
94 ashish 9149 
  """
9150 
  Attributes:
9151 
   - success
9152 
  """
9153 
 
9154 
  thrift_spec = (
3064 chandransh 9155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9156 
  )
9157 
 
3064 chandransh 9158 
  def __init__(self, success=None,):
94 ashish 9159 
    self.success = success
9160 
 
9161 
  def read(self, iprot):
9162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9164 
      return
9165 
    iprot.readStructBegin()
9166 
    while True:
9167 
      (fname, ftype, fid) = iprot.readFieldBegin()
9168 
      if ftype == TType.STOP:
9169 
        break
9170 
      if fid == 0:
3064 chandransh 9171 
        if ftype == TType.LIST:
9172 
          self.success = []
4133 chandransh 9173 
          (_etype115, _size112) = iprot.readListBegin()
9174 
          for _i116 in xrange(_size112):
9175 
            _elem117 = Alert()
9176 
            _elem117.read(iprot)
9177 
            self.success.append(_elem117)
3064 chandransh 9178 
          iprot.readListEnd()
94 ashish 9179 
        else:
9180 
          iprot.skip(ftype)
9181 
      else:
9182 
        iprot.skip(ftype)
9183 
      iprot.readFieldEnd()
9184 
    iprot.readStructEnd()
9185 
 
9186 
  def write(self, oprot):
9187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9189 
      return
3064 chandransh 9190 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9191 
    if self.success is not None:
3064 chandransh 9192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9194 
      for iter118 in self.success:
9195 
        iter118.write(oprot)
3064 chandransh 9196 
      oprot.writeListEnd()
94 ashish 9197 
      oprot.writeFieldEnd()
9198 
    oprot.writeFieldStop()
9199 
    oprot.writeStructEnd()
9200 
 
3431 rajveer 9201 
  def validate(self):
9202 
    return
9203 
 
9204 
 
94 ashish 9205 
  def __repr__(self):
9206 
    L = ['%s=%r' % (key, value)
9207 
      for key, value in self.__dict__.iteritems()]
9208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9209 
 
9210 
  def __eq__(self, other):
9211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9212 
 
9213 
  def __ne__(self, other):
9214 
    return not (self == other)
9215 
 
4394 rajveer 9216 
class addAlert_args:
94 ashish 9217 
  """
9218 
  Attributes:
3064 chandransh 9219 
   - type
4444 rajveer 9220 
   - warehouseId
4394 rajveer 9221 
   - description
94 ashish 9222 
  """
9223 
 
9224 
  thrift_spec = (
9225 
    None, # 0
4394 rajveer 9226 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9227 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9228 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9229 
  )
9230 
 
4444 rajveer 9231 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9232 
    self.type = type
4444 rajveer 9233 
    self.warehouseId = warehouseId
4394 rajveer 9234 
    self.description = description
94 ashish 9235 
 
9236 
  def read(self, iprot):
9237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9239 
      return
9240 
    iprot.readStructBegin()
9241 
    while True:
9242 
      (fname, ftype, fid) = iprot.readFieldBegin()
9243 
      if ftype == TType.STOP:
9244 
        break
9245 
      if fid == 1:
9246 
        if ftype == TType.I64:
4394 rajveer 9247 
          self.type = iprot.readI64();
94 ashish 9248 
        else:
9249 
          iprot.skip(ftype)
3064 chandransh 9250 
      elif fid == 2:
4444 rajveer 9251 
        if ftype == TType.I64:
9252 
          self.warehouseId = iprot.readI64();
9253 
        else:
9254 
          iprot.skip(ftype)
9255 
      elif fid == 3:
3064 chandransh 9256 
        if ftype == TType.STRING:
4394 rajveer 9257 
          self.description = iprot.readString();
3064 chandransh 9258 
        else:
9259 
          iprot.skip(ftype)
94 ashish 9260 
      else:
9261 
        iprot.skip(ftype)
9262 
      iprot.readFieldEnd()
9263 
    iprot.readStructEnd()
9264 
 
9265 
  def write(self, oprot):
9266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9268 
      return
4394 rajveer 9269 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9270 
    if self.type is not None:
4394 rajveer 9271 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9272 
      oprot.writeI64(self.type)
9273 
      oprot.writeFieldEnd()
4444 rajveer 9274 
    if self.warehouseId is not None:
9275 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9276 
      oprot.writeI64(self.warehouseId)
9277 
      oprot.writeFieldEnd()
4394 rajveer 9278 
    if self.description is not None:
4444 rajveer 9279 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9280 
      oprot.writeString(self.description)
3064 chandransh 9281 
      oprot.writeFieldEnd()
94 ashish 9282 
    oprot.writeFieldStop()
9283 
    oprot.writeStructEnd()
9284 
 
3431 rajveer 9285 
  def validate(self):
9286 
    return
9287 
 
9288 
 
94 ashish 9289 
  def __repr__(self):
9290 
    L = ['%s=%r' % (key, value)
9291 
      for key, value in self.__dict__.iteritems()]
9292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9293 
 
9294 
  def __eq__(self, other):
9295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9296 
 
9297 
  def __ne__(self, other):
9298 
    return not (self == other)
9299 
 
4394 rajveer 9300 
class addAlert_result:
3064 chandransh 9301 
 
9302 
  thrift_spec = (
9303 
  )
9304 
 
9305 
  def read(self, iprot):
9306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9308 
      return
9309 
    iprot.readStructBegin()
9310 
    while True:
9311 
      (fname, ftype, fid) = iprot.readFieldBegin()
9312 
      if ftype == TType.STOP:
9313 
        break
9314 
      else:
9315 
        iprot.skip(ftype)
9316 
      iprot.readFieldEnd()
9317 
    iprot.readStructEnd()
9318 
 
9319 
  def write(self, oprot):
9320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9322 
      return
4394 rajveer 9323 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9324 
    oprot.writeFieldStop()
9325 
    oprot.writeStructEnd()
9326 
 
3431 rajveer 9327 
  def validate(self):
9328 
    return
9329 
 
9330 
 
3064 chandransh 9331 
  def __repr__(self):
9332 
    L = ['%s=%r' % (key, value)
9333 
      for key, value in self.__dict__.iteritems()]
9334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9335 
 
9336 
  def __eq__(self, other):
9337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9338 
 
9339 
  def __ne__(self, other):
9340 
    return not (self == other)
9341 
 
4444 rajveer 9342 
class markAlertsAsSeen_args:
9343 
  """
9344 
  Attributes:
9345 
   - warehouseId
9346 
  """
9347 
 
9348 
  thrift_spec = (
9349 
    None, # 0
9350 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9351 
  )
9352 
 
9353 
  def __init__(self, warehouseId=None,):
9354 
    self.warehouseId = warehouseId
9355 
 
9356 
  def read(self, iprot):
9357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9359 
      return
9360 
    iprot.readStructBegin()
9361 
    while True:
9362 
      (fname, ftype, fid) = iprot.readFieldBegin()
9363 
      if ftype == TType.STOP:
9364 
        break
9365 
      if fid == 1:
9366 
        if ftype == TType.I64:
9367 
          self.warehouseId = iprot.readI64();
9368 
        else:
9369 
          iprot.skip(ftype)
9370 
      else:
9371 
        iprot.skip(ftype)
9372 
      iprot.readFieldEnd()
9373 
    iprot.readStructEnd()
9374 
 
9375 
  def write(self, oprot):
9376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9378 
      return
9379 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9380 
    if self.warehouseId is not None:
9381 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9382 
      oprot.writeI64(self.warehouseId)
9383 
      oprot.writeFieldEnd()
9384 
    oprot.writeFieldStop()
9385 
    oprot.writeStructEnd()
9386 
 
9387 
  def validate(self):
9388 
    return
9389 
 
9390 
 
9391 
  def __repr__(self):
9392 
    L = ['%s=%r' % (key, value)
9393 
      for key, value in self.__dict__.iteritems()]
9394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9395 
 
9396 
  def __eq__(self, other):
9397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9398 
 
9399 
  def __ne__(self, other):
9400 
    return not (self == other)
9401 
 
9402 
class markAlertsAsSeen_result:
9403 
 
9404 
  thrift_spec = (
9405 
  )
9406 
 
9407 
  def read(self, iprot):
9408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9410 
      return
9411 
    iprot.readStructBegin()
9412 
    while True:
9413 
      (fname, ftype, fid) = iprot.readFieldBegin()
9414 
      if ftype == TType.STOP:
9415 
        break
9416 
      else:
9417 
        iprot.skip(ftype)
9418 
      iprot.readFieldEnd()
9419 
    iprot.readStructEnd()
9420 
 
9421 
  def write(self, oprot):
9422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9424 
      return
9425 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9426 
    oprot.writeFieldStop()
9427 
    oprot.writeStructEnd()
9428 
 
9429 
  def validate(self):
9430 
    return
9431 
 
9432 
 
9433 
  def __repr__(self):
9434 
    L = ['%s=%r' % (key, value)
9435 
      for key, value in self.__dict__.iteritems()]
9436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9437 
 
9438 
  def __eq__(self, other):
9439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9440 
 
9441 
  def __ne__(self, other):
9442 
    return not (self == other)
9443 
 
3064 chandransh 9444 
class getValidOrderCount_args:
9445 
 
9446 
  thrift_spec = (
9447 
  )
9448 
 
9449 
  def read(self, iprot):
9450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9452 
      return
9453 
    iprot.readStructBegin()
9454 
    while True:
9455 
      (fname, ftype, fid) = iprot.readFieldBegin()
9456 
      if ftype == TType.STOP:
9457 
        break
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
9467 
    oprot.writeStructBegin('getValidOrderCount_args')
9468 
    oprot.writeFieldStop()
9469 
    oprot.writeStructEnd()
9470 
 
3431 rajveer 9471 
  def validate(self):
9472 
    return
9473 
 
9474 
 
3064 chandransh 9475 
  def __repr__(self):
9476 
    L = ['%s=%r' % (key, value)
9477 
      for key, value in self.__dict__.iteritems()]
9478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9479 
 
9480 
  def __eq__(self, other):
9481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9482 
 
9483 
  def __ne__(self, other):
9484 
    return not (self == other)
9485 
 
9486 
class getValidOrderCount_result:
94 ashish 9487 
  """
9488 
  Attributes:
9489 
   - success
9490 
  """
9491 
 
9492 
  thrift_spec = (
3064 chandransh 9493 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9494 
  )
9495 
 
3064 chandransh 9496 
  def __init__(self, success=None,):
94 ashish 9497 
    self.success = success
9498 
 
9499 
  def read(self, iprot):
9500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9502 
      return
9503 
    iprot.readStructBegin()
9504 
    while True:
9505 
      (fname, ftype, fid) = iprot.readFieldBegin()
9506 
      if ftype == TType.STOP:
9507 
        break
9508 
      if fid == 0:
3064 chandransh 9509 
        if ftype == TType.I64:
9510 
          self.success = iprot.readI64();
94 ashish 9511 
        else:
9512 
          iprot.skip(ftype)
9513 
      else:
9514 
        iprot.skip(ftype)
9515 
      iprot.readFieldEnd()
9516 
    iprot.readStructEnd()
9517 
 
9518 
  def write(self, oprot):
9519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9521 
      return
3064 chandransh 9522 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9523 
    if self.success is not None:
3064 chandransh 9524 
      oprot.writeFieldBegin('success', TType.I64, 0)
9525 
      oprot.writeI64(self.success)
94 ashish 9526 
      oprot.writeFieldEnd()
9527 
    oprot.writeFieldStop()
9528 
    oprot.writeStructEnd()
9529 
 
3431 rajveer 9530 
  def validate(self):
9531 
    return
9532 
 
9533 
 
94 ashish 9534 
  def __repr__(self):
9535 
    L = ['%s=%r' % (key, value)
9536 
      for key, value in self.__dict__.iteritems()]
9537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9538 
 
9539 
  def __eq__(self, other):
9540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9541 
 
9542 
  def __ne__(self, other):
9543 
    return not (self == other)
9544 
 
3064 chandransh 9545 
class getNoOfCustomersWithSuccessfulTransaction_args:
9546 
 
9547 
  thrift_spec = (
9548 
  )
9549 
 
9550 
  def read(self, iprot):
9551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9553 
      return
9554 
    iprot.readStructBegin()
9555 
    while True:
9556 
      (fname, ftype, fid) = iprot.readFieldBegin()
9557 
      if ftype == TType.STOP:
9558 
        break
9559 
      else:
9560 
        iprot.skip(ftype)
9561 
      iprot.readFieldEnd()
9562 
    iprot.readStructEnd()
9563 
 
9564 
  def write(self, oprot):
9565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9567 
      return
9568 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9569 
    oprot.writeFieldStop()
9570 
    oprot.writeStructEnd()
9571 
 
3431 rajveer 9572 
  def validate(self):
9573 
    return
9574 
 
9575 
 
3064 chandransh 9576 
  def __repr__(self):
9577 
    L = ['%s=%r' % (key, value)
9578 
      for key, value in self.__dict__.iteritems()]
9579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9580 
 
9581 
  def __eq__(self, other):
9582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9583 
 
9584 
  def __ne__(self, other):
9585 
    return not (self == other)
9586 
 
9587 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9588 
  """
9589 
  Attributes:
3064 chandransh 9590 
   - success
94 ashish 9591 
  """
9592 
 
9593 
  thrift_spec = (
3064 chandransh 9594 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9595 
  )
9596 
 
3064 chandransh 9597 
  def __init__(self, success=None,):
9598 
    self.success = success
94 ashish 9599 
 
9600 
  def read(self, iprot):
9601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9603 
      return
9604 
    iprot.readStructBegin()
9605 
    while True:
9606 
      (fname, ftype, fid) = iprot.readFieldBegin()
9607 
      if ftype == TType.STOP:
9608 
        break
3064 chandransh 9609 
      if fid == 0:
94 ashish 9610 
        if ftype == TType.I64:
3064 chandransh 9611 
          self.success = iprot.readI64();
94 ashish 9612 
        else:
9613 
          iprot.skip(ftype)
9614 
      else:
9615 
        iprot.skip(ftype)
9616 
      iprot.readFieldEnd()
9617 
    iprot.readStructEnd()
9618 
 
9619 
  def write(self, oprot):
9620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9622 
      return
3064 chandransh 9623 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9624 
    if self.success is not None:
3064 chandransh 9625 
      oprot.writeFieldBegin('success', TType.I64, 0)
9626 
      oprot.writeI64(self.success)
94 ashish 9627 
      oprot.writeFieldEnd()
9628 
    oprot.writeFieldStop()
9629 
    oprot.writeStructEnd()
9630 
 
3431 rajveer 9631 
  def validate(self):
9632 
    return
9633 
 
9634 
 
94 ashish 9635 
  def __repr__(self):
9636 
    L = ['%s=%r' % (key, value)
9637 
      for key, value in self.__dict__.iteritems()]
9638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9639 
 
9640 
  def __eq__(self, other):
9641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9642 
 
9643 
  def __ne__(self, other):
9644 
    return not (self == other)
9645 
 
3064 chandransh 9646 
class getValidOrdersAmountRange_args:
9647 
 
9648 
  thrift_spec = (
9649 
  )
9650 
 
9651 
  def read(self, iprot):
9652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9654 
      return
9655 
    iprot.readStructBegin()
9656 
    while True:
9657 
      (fname, ftype, fid) = iprot.readFieldBegin()
9658 
      if ftype == TType.STOP:
9659 
        break
9660 
      else:
9661 
        iprot.skip(ftype)
9662 
      iprot.readFieldEnd()
9663 
    iprot.readStructEnd()
9664 
 
9665 
  def write(self, oprot):
9666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9668 
      return
9669 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9670 
    oprot.writeFieldStop()
9671 
    oprot.writeStructEnd()
9672 
 
3431 rajveer 9673 
  def validate(self):
9674 
    return
9675 
 
9676 
 
3064 chandransh 9677 
  def __repr__(self):
9678 
    L = ['%s=%r' % (key, value)
9679 
      for key, value in self.__dict__.iteritems()]
9680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9681 
 
9682 
  def __eq__(self, other):
9683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9684 
 
9685 
  def __ne__(self, other):
9686 
    return not (self == other)
9687 
 
9688 
class getValidOrdersAmountRange_result:
94 ashish 9689 
  """
9690 
  Attributes:
9691 
   - success
9692 
  """
9693 
 
9694 
  thrift_spec = (
3064 chandransh 9695 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9696 
  )
9697 
 
3064 chandransh 9698 
  def __init__(self, success=None,):
94 ashish 9699 
    self.success = success
9700 
 
9701 
  def read(self, iprot):
9702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9704 
      return
9705 
    iprot.readStructBegin()
9706 
    while True:
9707 
      (fname, ftype, fid) = iprot.readFieldBegin()
9708 
      if ftype == TType.STOP:
9709 
        break
9710 
      if fid == 0:
483 rajveer 9711 
        if ftype == TType.LIST:
9712 
          self.success = []
4133 chandransh 9713 
          (_etype122, _size119) = iprot.readListBegin()
9714 
          for _i123 in xrange(_size119):
9715 
            _elem124 = iprot.readDouble();
9716 
            self.success.append(_elem124)
483 rajveer 9717 
          iprot.readListEnd()
94 ashish 9718 
        else:
9719 
          iprot.skip(ftype)
9720 
      else:
9721 
        iprot.skip(ftype)
9722 
      iprot.readFieldEnd()
9723 
    iprot.readStructEnd()
9724 
 
9725 
  def write(self, oprot):
9726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9728 
      return
3064 chandransh 9729 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9730 
    if self.success is not None:
483 rajveer 9731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9732 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9733 
      for iter125 in self.success:
9734 
        oprot.writeDouble(iter125)
483 rajveer 9735 
      oprot.writeListEnd()
94 ashish 9736 
      oprot.writeFieldEnd()
9737 
    oprot.writeFieldStop()
9738 
    oprot.writeStructEnd()
9739 
 
3431 rajveer 9740 
  def validate(self):
9741 
    return
9742 
 
9743 
 
94 ashish 9744 
  def __repr__(self):
9745 
    L = ['%s=%r' % (key, value)
9746 
      for key, value in self.__dict__.iteritems()]
9747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9748 
 
9749 
  def __eq__(self, other):
9750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9751 
 
9752 
  def __ne__(self, other):
9753 
    return not (self == other)
9754 
 
3064 chandransh 9755 
class getValidOrders_args:
1528 ankur.sing 9756 
  """
9757 
  Attributes:
3064 chandransh 9758 
   - limit
1528 ankur.sing 9759 
  """
9760 
 
9761 
  thrift_spec = (
9762 
    None, # 0
3064 chandransh 9763 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9764 
  )
9765 
 
3064 chandransh 9766 
  def __init__(self, limit=None,):
9767 
    self.limit = limit
1528 ankur.sing 9768 
 
9769 
  def read(self, iprot):
9770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9772 
      return
9773 
    iprot.readStructBegin()
9774 
    while True:
9775 
      (fname, ftype, fid) = iprot.readFieldBegin()
9776 
      if ftype == TType.STOP:
9777 
        break
9778 
      if fid == 1:
9779 
        if ftype == TType.I64:
3064 chandransh 9780 
          self.limit = iprot.readI64();
1528 ankur.sing 9781 
        else:
9782 
          iprot.skip(ftype)
9783 
      else:
9784 
        iprot.skip(ftype)
9785 
      iprot.readFieldEnd()
9786 
    iprot.readStructEnd()
9787 
 
9788 
  def write(self, oprot):
9789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9791 
      return
3064 chandransh 9792 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9793 
    if self.limit is not None:
3064 chandransh 9794 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9795 
      oprot.writeI64(self.limit)
1528 ankur.sing 9796 
      oprot.writeFieldEnd()
9797 
    oprot.writeFieldStop()
9798 
    oprot.writeStructEnd()
9799 
 
3431 rajveer 9800 
  def validate(self):
9801 
    return
9802 
 
9803 
 
1528 ankur.sing 9804 
  def __repr__(self):
9805 
    L = ['%s=%r' % (key, value)
9806 
      for key, value in self.__dict__.iteritems()]
9807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9808 
 
9809 
  def __eq__(self, other):
9810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9811 
 
9812 
  def __ne__(self, other):
9813 
    return not (self == other)
9814 
 
3064 chandransh 9815 
class getValidOrders_result:
1528 ankur.sing 9816 
  """
9817 
  Attributes:
9818 
   - success
9819 
  """
9820 
 
9821 
  thrift_spec = (
3064 chandransh 9822 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9823 
  )
9824 
 
3064 chandransh 9825 
  def __init__(self, success=None,):
1528 ankur.sing 9826 
    self.success = success
9827 
 
9828 
  def read(self, iprot):
9829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9831 
      return
9832 
    iprot.readStructBegin()
9833 
    while True:
9834 
      (fname, ftype, fid) = iprot.readFieldBegin()
9835 
      if ftype == TType.STOP:
9836 
        break
9837 
      if fid == 0:
3064 chandransh 9838 
        if ftype == TType.LIST:
9839 
          self.success = []
4133 chandransh 9840 
          (_etype129, _size126) = iprot.readListBegin()
9841 
          for _i130 in xrange(_size126):
9842 
            _elem131 = Order()
9843 
            _elem131.read(iprot)
9844 
            self.success.append(_elem131)
3064 chandransh 9845 
          iprot.readListEnd()
1528 ankur.sing 9846 
        else:
9847 
          iprot.skip(ftype)
9848 
      else:
9849 
        iprot.skip(ftype)
9850 
      iprot.readFieldEnd()
9851 
    iprot.readStructEnd()
9852 
 
9853 
  def write(self, oprot):
9854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9856 
      return
3064 chandransh 9857 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9858 
    if self.success is not None:
3064 chandransh 9859 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9860 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9861 
      for iter132 in self.success:
9862 
        iter132.write(oprot)
3064 chandransh 9863 
      oprot.writeListEnd()
1528 ankur.sing 9864 
      oprot.writeFieldEnd()
9865 
    oprot.writeFieldStop()
9866 
    oprot.writeStructEnd()
9867 
 
3431 rajveer 9868 
  def validate(self):
9869 
    return
9870 
 
9871 
 
1528 ankur.sing 9872 
  def __repr__(self):
9873 
    L = ['%s=%r' % (key, value)
9874 
      for key, value in self.__dict__.iteritems()]
9875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9876 
 
9877 
  def __eq__(self, other):
9878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9879 
 
9880 
  def __ne__(self, other):
9881 
    return not (self == other)
9882 
 
1220 chandransh 9883 
class batchOrders_args:
9884 
  """
9885 
  Attributes:
9886 
   - warehouseId
9887 
  """
9888 
 
9889 
  thrift_spec = (
9890 
    None, # 0
9891 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9892 
  )
9893 
 
9894 
  def __init__(self, warehouseId=None,):
9895 
    self.warehouseId = warehouseId
9896 
 
9897 
  def read(self, iprot):
9898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9900 
      return
9901 
    iprot.readStructBegin()
9902 
    while True:
9903 
      (fname, ftype, fid) = iprot.readFieldBegin()
9904 
      if ftype == TType.STOP:
9905 
        break
9906 
      if fid == 1:
9907 
        if ftype == TType.I64:
9908 
          self.warehouseId = iprot.readI64();
9909 
        else:
9910 
          iprot.skip(ftype)
9911 
      else:
9912 
        iprot.skip(ftype)
9913 
      iprot.readFieldEnd()
9914 
    iprot.readStructEnd()
9915 
 
9916 
  def write(self, oprot):
9917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9919 
      return
9920 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9921 
    if self.warehouseId is not None:
1220 chandransh 9922 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9923 
      oprot.writeI64(self.warehouseId)
9924 
      oprot.writeFieldEnd()
9925 
    oprot.writeFieldStop()
9926 
    oprot.writeStructEnd()
9927 
 
3431 rajveer 9928 
  def validate(self):
9929 
    return
9930 
 
9931 
 
1220 chandransh 9932 
  def __repr__(self):
9933 
    L = ['%s=%r' % (key, value)
9934 
      for key, value in self.__dict__.iteritems()]
9935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9936 
 
9937 
  def __eq__(self, other):
9938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9939 
 
9940 
  def __ne__(self, other):
9941 
    return not (self == other)
9942 
 
9943 
class batchOrders_result:
9944 
  """
9945 
  Attributes:
9946 
   - success
9947 
   - ex
9948 
  """
9949 
 
9950 
  thrift_spec = (
9951 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9953 
  )
9954 
 
9955 
  def __init__(self, success=None, ex=None,):
9956 
    self.success = success
9957 
    self.ex = ex
9958 
 
9959 
  def read(self, iprot):
9960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9962 
      return
9963 
    iprot.readStructBegin()
9964 
    while True:
9965 
      (fname, ftype, fid) = iprot.readFieldBegin()
9966 
      if ftype == TType.STOP:
9967 
        break
9968 
      if fid == 0:
9969 
        if ftype == TType.LIST:
9970 
          self.success = []
4133 chandransh 9971 
          (_etype136, _size133) = iprot.readListBegin()
9972 
          for _i137 in xrange(_size133):
9973 
            _elem138 = Order()
9974 
            _elem138.read(iprot)
9975 
            self.success.append(_elem138)
1220 chandransh 9976 
          iprot.readListEnd()
9977 
        else:
9978 
          iprot.skip(ftype)
9979 
      elif fid == 1:
9980 
        if ftype == TType.STRUCT:
9981 
          self.ex = TransactionServiceException()
9982 
          self.ex.read(iprot)
9983 
        else:
9984 
          iprot.skip(ftype)
9985 
      else:
9986 
        iprot.skip(ftype)
9987 
      iprot.readFieldEnd()
9988 
    iprot.readStructEnd()
9989 
 
9990 
  def write(self, oprot):
9991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9993 
      return
9994 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9995 
    if self.success is not None:
1220 chandransh 9996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9997 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9998 
      for iter139 in self.success:
9999 
        iter139.write(oprot)
1220 chandransh 10000 
      oprot.writeListEnd()
10001 
      oprot.writeFieldEnd()
3431 rajveer 10002 
    if self.ex is not None:
1220 chandransh 10003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10004 
      self.ex.write(oprot)
10005 
      oprot.writeFieldEnd()
10006 
    oprot.writeFieldStop()
10007 
    oprot.writeStructEnd()
10008 
 
3431 rajveer 10009 
  def validate(self):
10010 
    return
10011 
 
10012 
 
1220 chandransh 10013 
  def __repr__(self):
10014 
    L = ['%s=%r' % (key, value)
10015 
      for key, value in self.__dict__.iteritems()]
10016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10017 
 
10018 
  def __eq__(self, other):
10019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10020 
 
10021 
  def __ne__(self, other):
10022 
    return not (self == other)
10023 
 
1208 chandransh 10024 
class markOrderAsOutOfStock_args:
10025 
  """
10026 
  Attributes:
10027 
   - orderId
10028 
  """
10029 
 
10030 
  thrift_spec = (
10031 
    None, # 0
10032 
    (1, TType.I64, 'orderId', None, None, ), # 1
10033 
  )
10034 
 
10035 
  def __init__(self, orderId=None,):
10036 
    self.orderId = orderId
10037 
 
10038 
  def read(self, iprot):
10039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10041 
      return
10042 
    iprot.readStructBegin()
10043 
    while True:
10044 
      (fname, ftype, fid) = iprot.readFieldBegin()
10045 
      if ftype == TType.STOP:
10046 
        break
10047 
      if fid == 1:
10048 
        if ftype == TType.I64:
10049 
          self.orderId = iprot.readI64();
10050 
        else:
10051 
          iprot.skip(ftype)
10052 
      else:
10053 
        iprot.skip(ftype)
10054 
      iprot.readFieldEnd()
10055 
    iprot.readStructEnd()
10056 
 
10057 
  def write(self, oprot):
10058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10060 
      return
10061 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10062 
    if self.orderId is not None:
1208 chandransh 10063 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10064 
      oprot.writeI64(self.orderId)
10065 
      oprot.writeFieldEnd()
10066 
    oprot.writeFieldStop()
10067 
    oprot.writeStructEnd()
10068 
 
3431 rajveer 10069 
  def validate(self):
10070 
    return
10071 
 
10072 
 
1208 chandransh 10073 
  def __repr__(self):
10074 
    L = ['%s=%r' % (key, value)
10075 
      for key, value in self.__dict__.iteritems()]
10076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10077 
 
10078 
  def __eq__(self, other):
10079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10080 
 
10081 
  def __ne__(self, other):
10082 
    return not (self == other)
10083 
 
10084 
class markOrderAsOutOfStock_result:
10085 
  """
10086 
  Attributes:
10087 
   - success
10088 
   - ex
10089 
  """
10090 
 
10091 
  thrift_spec = (
10092 
    (0, TType.BOOL, 'success', None, None, ), # 0
10093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10094 
  )
10095 
 
10096 
  def __init__(self, success=None, ex=None,):
10097 
    self.success = success
10098 
    self.ex = ex
10099 
 
10100 
  def read(self, iprot):
10101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10103 
      return
10104 
    iprot.readStructBegin()
10105 
    while True:
10106 
      (fname, ftype, fid) = iprot.readFieldBegin()
10107 
      if ftype == TType.STOP:
10108 
        break
10109 
      if fid == 0:
10110 
        if ftype == TType.BOOL:
10111 
          self.success = iprot.readBool();
10112 
        else:
10113 
          iprot.skip(ftype)
10114 
      elif fid == 1:
10115 
        if ftype == TType.STRUCT:
10116 
          self.ex = TransactionServiceException()
10117 
          self.ex.read(iprot)
10118 
        else:
10119 
          iprot.skip(ftype)
10120 
      else:
10121 
        iprot.skip(ftype)
10122 
      iprot.readFieldEnd()
10123 
    iprot.readStructEnd()
10124 
 
10125 
  def write(self, oprot):
10126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10128 
      return
10129 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10130 
    if self.success is not None:
1208 chandransh 10131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10132 
      oprot.writeBool(self.success)
10133 
      oprot.writeFieldEnd()
3431 rajveer 10134 
    if self.ex is not None:
1208 chandransh 10135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10136 
      self.ex.write(oprot)
10137 
      oprot.writeFieldEnd()
10138 
    oprot.writeFieldStop()
10139 
    oprot.writeStructEnd()
10140 
 
3431 rajveer 10141 
  def validate(self):
10142 
    return
10143 
 
10144 
 
1208 chandransh 10145 
  def __repr__(self):
10146 
    L = ['%s=%r' % (key, value)
10147 
      for key, value in self.__dict__.iteritems()]
10148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10149 
 
10150 
  def __eq__(self, other):
10151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10152 
 
10153 
  def __ne__(self, other):
10154 
    return not (self == other)
10155 
 
3064 chandransh 10156 
class verifyOrder_args:
759 chandransh 10157 
  """
10158 
  Attributes:
3064 chandransh 10159 
   - orderId
759 chandransh 10160 
  """
10161 
 
10162 
  thrift_spec = (
10163 
    None, # 0
3064 chandransh 10164 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10165 
  )
10166 
 
3064 chandransh 10167 
  def __init__(self, orderId=None,):
10168 
    self.orderId = orderId
759 chandransh 10169 
 
10170 
  def read(self, iprot):
10171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10173 
      return
10174 
    iprot.readStructBegin()
10175 
    while True:
10176 
      (fname, ftype, fid) = iprot.readFieldBegin()
10177 
      if ftype == TType.STOP:
10178 
        break
10179 
      if fid == 1:
10180 
        if ftype == TType.I64:
3064 chandransh 10181 
          self.orderId = iprot.readI64();
759 chandransh 10182 
        else:
10183 
          iprot.skip(ftype)
10184 
      else:
10185 
        iprot.skip(ftype)
10186 
      iprot.readFieldEnd()
10187 
    iprot.readStructEnd()
10188 
 
10189 
  def write(self, oprot):
10190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10192 
      return
3064 chandransh 10193 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10194 
    if self.orderId is not None:
3064 chandransh 10195 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10196 
      oprot.writeI64(self.orderId)
759 chandransh 10197 
      oprot.writeFieldEnd()
10198 
    oprot.writeFieldStop()
10199 
    oprot.writeStructEnd()
10200 
 
3431 rajveer 10201 
  def validate(self):
10202 
    return
10203 
 
10204 
 
759 chandransh 10205 
  def __repr__(self):
10206 
    L = ['%s=%r' % (key, value)
10207 
      for key, value in self.__dict__.iteritems()]
10208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10209 
 
10210 
  def __eq__(self, other):
10211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10212 
 
10213 
  def __ne__(self, other):
10214 
    return not (self == other)
10215 
 
3064 chandransh 10216 
class verifyOrder_result:
759 chandransh 10217 
  """
10218 
  Attributes:
10219 
   - success
10220 
   - ex
10221 
  """
10222 
 
10223 
  thrift_spec = (
10224 
    (0, TType.BOOL, 'success', None, None, ), # 0
10225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10226 
  )
10227 
 
10228 
  def __init__(self, success=None, ex=None,):
10229 
    self.success = success
10230 
    self.ex = ex
10231 
 
10232 
  def read(self, iprot):
10233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10235 
      return
10236 
    iprot.readStructBegin()
10237 
    while True:
10238 
      (fname, ftype, fid) = iprot.readFieldBegin()
10239 
      if ftype == TType.STOP:
10240 
        break
10241 
      if fid == 0:
10242 
        if ftype == TType.BOOL:
10243 
          self.success = iprot.readBool();
10244 
        else:
10245 
          iprot.skip(ftype)
10246 
      elif fid == 1:
10247 
        if ftype == TType.STRUCT:
10248 
          self.ex = TransactionServiceException()
10249 
          self.ex.read(iprot)
10250 
        else:
10251 
          iprot.skip(ftype)
10252 
      else:
10253 
        iprot.skip(ftype)
10254 
      iprot.readFieldEnd()
10255 
    iprot.readStructEnd()
10256 
 
10257 
  def write(self, oprot):
10258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10260 
      return
3064 chandransh 10261 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10262 
    if self.success is not None:
759 chandransh 10263 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10264 
      oprot.writeBool(self.success)
10265 
      oprot.writeFieldEnd()
3431 rajveer 10266 
    if self.ex is not None:
759 chandransh 10267 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10268 
      self.ex.write(oprot)
10269 
      oprot.writeFieldEnd()
10270 
    oprot.writeFieldStop()
10271 
    oprot.writeStructEnd()
10272 
 
3431 rajveer 10273 
  def validate(self):
10274 
    return
10275 
 
10276 
 
759 chandransh 10277 
  def __repr__(self):
10278 
    L = ['%s=%r' % (key, value)
10279 
      for key, value in self.__dict__.iteritems()]
10280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10281 
 
10282 
  def __eq__(self, other):
10283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10284 
 
10285 
  def __ne__(self, other):
10286 
    return not (self == other)
10287 
 
3064 chandransh 10288 
class acceptOrder_args:
1113 chandransh 10289 
  """
10290 
  Attributes:
3064 chandransh 10291 
   - orderId
1113 chandransh 10292 
  """
10293 
 
10294 
  thrift_spec = (
10295 
    None, # 0
3064 chandransh 10296 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10297 
  )
10298 
 
3064 chandransh 10299 
  def __init__(self, orderId=None,):
10300 
    self.orderId = orderId
1113 chandransh 10301 
 
10302 
  def read(self, iprot):
10303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10305 
      return
10306 
    iprot.readStructBegin()
10307 
    while True:
10308 
      (fname, ftype, fid) = iprot.readFieldBegin()
10309 
      if ftype == TType.STOP:
10310 
        break
10311 
      if fid == 1:
10312 
        if ftype == TType.I64:
3064 chandransh 10313 
          self.orderId = iprot.readI64();
1113 chandransh 10314 
        else:
10315 
          iprot.skip(ftype)
10316 
      else:
10317 
        iprot.skip(ftype)
10318 
      iprot.readFieldEnd()
10319 
    iprot.readStructEnd()
10320 
 
10321 
  def write(self, oprot):
10322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10324 
      return
3064 chandransh 10325 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10326 
    if self.orderId is not None:
3064 chandransh 10327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10328 
      oprot.writeI64(self.orderId)
1113 chandransh 10329 
      oprot.writeFieldEnd()
10330 
    oprot.writeFieldStop()
10331 
    oprot.writeStructEnd()
10332 
 
3431 rajveer 10333 
  def validate(self):
10334 
    return
10335 
 
10336 
 
1113 chandransh 10337 
  def __repr__(self):
10338 
    L = ['%s=%r' % (key, value)
10339 
      for key, value in self.__dict__.iteritems()]
10340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10341 
 
10342 
  def __eq__(self, other):
10343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10344 
 
10345 
  def __ne__(self, other):
10346 
    return not (self == other)
10347 
 
3064 chandransh 10348 
class acceptOrder_result:
1113 chandransh 10349 
  """
10350 
  Attributes:
10351 
   - success
10352 
   - ex
10353 
  """
10354 
 
10355 
  thrift_spec = (
3064 chandransh 10356 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10358 
  )
10359 
 
10360 
  def __init__(self, success=None, ex=None,):
10361 
    self.success = success
10362 
    self.ex = ex
10363 
 
10364 
  def read(self, iprot):
10365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10367 
      return
10368 
    iprot.readStructBegin()
10369 
    while True:
10370 
      (fname, ftype, fid) = iprot.readFieldBegin()
10371 
      if ftype == TType.STOP:
10372 
        break
10373 
      if fid == 0:
3064 chandransh 10374 
        if ftype == TType.BOOL:
10375 
          self.success = iprot.readBool();
1113 chandransh 10376 
        else:
10377 
          iprot.skip(ftype)
10378 
      elif fid == 1:
10379 
        if ftype == TType.STRUCT:
10380 
          self.ex = TransactionServiceException()
10381 
          self.ex.read(iprot)
10382 
        else:
10383 
          iprot.skip(ftype)
10384 
      else:
10385 
        iprot.skip(ftype)
10386 
      iprot.readFieldEnd()
10387 
    iprot.readStructEnd()
10388 
 
10389 
  def write(self, oprot):
10390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10392 
      return
3064 chandransh 10393 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10394 
    if self.success is not None:
3064 chandransh 10395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10396 
      oprot.writeBool(self.success)
1113 chandransh 10397 
      oprot.writeFieldEnd()
3431 rajveer 10398 
    if self.ex is not None:
1113 chandransh 10399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10400 
      self.ex.write(oprot)
10401 
      oprot.writeFieldEnd()
10402 
    oprot.writeFieldStop()
10403 
    oprot.writeStructEnd()
10404 
 
3431 rajveer 10405 
  def validate(self):
10406 
    return
10407 
 
10408 
 
1113 chandransh 10409 
  def __repr__(self):
10410 
    L = ['%s=%r' % (key, value)
10411 
      for key, value in self.__dict__.iteritems()]
10412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10413 
 
10414 
  def __eq__(self, other):
10415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10416 
 
10417 
  def __ne__(self, other):
10418 
    return not (self == other)
10419 
 
3064 chandransh 10420 
class addBillingDetails_args:
1135 chandransh 10421 
  """
10422 
  Attributes:
3064 chandransh 10423 
   - orderId
10424 
   - invoice_number
4658 mandeep.dh 10425 
   - serialNumber
4283 anupam.sin 10426 
   - itemNumber
3064 chandransh 10427 
   - billed_by
4264 rajveer 10428 
   - jacketNumber
4283 anupam.sin 10429 
   - billingType
10430 
   - vendorId
1135 chandransh 10431 
  """
10432 
 
10433 
  thrift_spec = (
10434 
    None, # 0
3064 chandransh 10435 
    (1, TType.I64, 'orderId', None, None, ), # 1
10436 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10437 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10438 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10439 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10440 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10441 
    (7, TType.I64, 'billingType', None, None, ), # 7
10442 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10443 
  )
10444 
 
4658 mandeep.dh 10445 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10446 
    self.orderId = orderId
10447 
    self.invoice_number = invoice_number
4658 mandeep.dh 10448 
    self.serialNumber = serialNumber
4283 anupam.sin 10449 
    self.itemNumber = itemNumber
3064 chandransh 10450 
    self.billed_by = billed_by
4264 rajveer 10451 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10452 
    self.billingType = billingType
10453 
    self.vendorId = vendorId
1135 chandransh 10454 
 
10455 
  def read(self, iprot):
10456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10458 
      return
10459 
    iprot.readStructBegin()
10460 
    while True:
10461 
      (fname, ftype, fid) = iprot.readFieldBegin()
10462 
      if ftype == TType.STOP:
10463 
        break
10464 
      if fid == 1:
10465 
        if ftype == TType.I64:
3064 chandransh 10466 
          self.orderId = iprot.readI64();
1135 chandransh 10467 
        else:
10468 
          iprot.skip(ftype)
10469 
      elif fid == 2:
3064 chandransh 10470 
        if ftype == TType.STRING:
10471 
          self.invoice_number = iprot.readString();
1135 chandransh 10472 
        else:
10473 
          iprot.skip(ftype)
3064 chandransh 10474 
      elif fid == 3:
4658 mandeep.dh 10475 
        if ftype == TType.STRING:
10476 
          self.serialNumber = iprot.readString();
3064 chandransh 10477 
        else:
10478 
          iprot.skip(ftype)
10479 
      elif fid == 4:
10480 
        if ftype == TType.STRING:
10481 
          self.itemNumber = iprot.readString();
10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      elif fid == 5:
10485 
        if ftype == TType.STRING:
4283 anupam.sin 10486 
          self.billed_by = iprot.readString();
3064 chandransh 10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 6:
10490 
        if ftype == TType.I64:
4283 anupam.sin 10491 
          self.jacketNumber = iprot.readI64();
10492 
        else:
10493 
          iprot.skip(ftype)
10494 
      elif fid == 7:
10495 
        if ftype == TType.I64:
3064 chandransh 10496 
          self.billingType = iprot.readI64();
10497 
        else:
10498 
          iprot.skip(ftype)
4283 anupam.sin 10499 
      elif fid == 8:
10500 
        if ftype == TType.I64:
10501 
          self.vendorId = iprot.readI64();
10502 
        else:
10503 
          iprot.skip(ftype)
1246 chandransh 10504 
      else:
10505 
        iprot.skip(ftype)
10506 
      iprot.readFieldEnd()
10507 
    iprot.readStructEnd()
10508 
 
10509 
  def write(self, oprot):
10510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10512 
      return
4283 anupam.sin 10513 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10514 
    if self.orderId is not None:
3064 chandransh 10515 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10516 
      oprot.writeI64(self.orderId)
1246 chandransh 10517 
      oprot.writeFieldEnd()
4283 anupam.sin 10518 
    if self.invoice_number is not None:
10519 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10520 
      oprot.writeString(self.invoice_number)
1246 chandransh 10521 
      oprot.writeFieldEnd()
4658 mandeep.dh 10522 
    if self.serialNumber is not None:
10523 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10524 
      oprot.writeString(self.serialNumber)
3064 chandransh 10525 
      oprot.writeFieldEnd()
3431 rajveer 10526 
    if self.itemNumber is not None:
3064 chandransh 10527 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10528 
      oprot.writeString(self.itemNumber)
10529 
      oprot.writeFieldEnd()
4283 anupam.sin 10530 
    if self.billed_by is not None:
10531 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10532 
      oprot.writeString(self.billed_by)
3064 chandransh 10533 
      oprot.writeFieldEnd()
4283 anupam.sin 10534 
    if self.jacketNumber is not None:
10535 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10536 
      oprot.writeI64(self.jacketNumber)
10537 
      oprot.writeFieldEnd()
3431 rajveer 10538 
    if self.billingType is not None:
4283 anupam.sin 10539 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10540 
      oprot.writeI64(self.billingType)
10541 
      oprot.writeFieldEnd()
4283 anupam.sin 10542 
    if self.vendorId is not None:
10543 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10544 
      oprot.writeI64(self.vendorId)
10545 
      oprot.writeFieldEnd()
1246 chandransh 10546 
    oprot.writeFieldStop()
10547 
    oprot.writeStructEnd()
10548 
 
3431 rajveer 10549 
  def validate(self):
10550 
    return
10551 
 
10552 
 
1246 chandransh 10553 
  def __repr__(self):
10554 
    L = ['%s=%r' % (key, value)
10555 
      for key, value in self.__dict__.iteritems()]
10556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10557 
 
10558 
  def __eq__(self, other):
10559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10560 
 
10561 
  def __ne__(self, other):
10562 
    return not (self == other)
10563 
 
4283 anupam.sin 10564 
class addBillingDetails_result:
1246 chandransh 10565 
  """
10566 
  Attributes:
3064 chandransh 10567 
   - success
1246 chandransh 10568 
   - ex
10569 
  """
10570 
 
10571 
  thrift_spec = (
3064 chandransh 10572 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10574 
  )
10575 
 
3064 chandransh 10576 
  def __init__(self, success=None, ex=None,):
10577 
    self.success = success
1246 chandransh 10578 
    self.ex = ex
10579 
 
10580 
  def read(self, iprot):
10581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10583 
      return
10584 
    iprot.readStructBegin()
10585 
    while True:
10586 
      (fname, ftype, fid) = iprot.readFieldBegin()
10587 
      if ftype == TType.STOP:
10588 
        break
3064 chandransh 10589 
      if fid == 0:
10590 
        if ftype == TType.BOOL:
10591 
          self.success = iprot.readBool();
10592 
        else:
10593 
          iprot.skip(ftype)
10594 
      elif fid == 1:
1246 chandransh 10595 
        if ftype == TType.STRUCT:
10596 
          self.ex = TransactionServiceException()
10597 
          self.ex.read(iprot)
10598 
        else:
10599 
          iprot.skip(ftype)
10600 
      else:
10601 
        iprot.skip(ftype)
10602 
      iprot.readFieldEnd()
10603 
    iprot.readStructEnd()
10604 
 
10605 
  def write(self, oprot):
10606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10608 
      return
4283 anupam.sin 10609 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10610 
    if self.success is not None:
3064 chandransh 10611 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10612 
      oprot.writeBool(self.success)
10613 
      oprot.writeFieldEnd()
3431 rajveer 10614 
    if self.ex is not None:
1246 chandransh 10615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10616 
      self.ex.write(oprot)
10617 
      oprot.writeFieldEnd()
10618 
    oprot.writeFieldStop()
10619 
    oprot.writeStructEnd()
10620 
 
3431 rajveer 10621 
  def validate(self):
10622 
    return
10623 
 
10624 
 
1246 chandransh 10625 
  def __repr__(self):
10626 
    L = ['%s=%r' % (key, value)
10627 
      for key, value in self.__dict__.iteritems()]
10628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10629 
 
10630 
  def __eq__(self, other):
10631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10632 
 
10633 
  def __ne__(self, other):
10634 
    return not (self == other)
10635 
 
4579 rajveer 10636 
class addInvoiceNumber_args:
10637 
  """
10638 
  Attributes:
10639 
   - orderId
10640 
   - invoiceNumber
10641 
  """
10642 
 
10643 
  thrift_spec = (
10644 
    None, # 0
10645 
    (1, TType.I64, 'orderId', None, None, ), # 1
10646 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10647 
  )
10648 
 
10649 
  def __init__(self, orderId=None, invoiceNumber=None,):
10650 
    self.orderId = orderId
10651 
    self.invoiceNumber = invoiceNumber
10652 
 
10653 
  def read(self, iprot):
10654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10656 
      return
10657 
    iprot.readStructBegin()
10658 
    while True:
10659 
      (fname, ftype, fid) = iprot.readFieldBegin()
10660 
      if ftype == TType.STOP:
10661 
        break
10662 
      if fid == 1:
10663 
        if ftype == TType.I64:
10664 
          self.orderId = iprot.readI64();
10665 
        else:
10666 
          iprot.skip(ftype)
10667 
      elif fid == 2:
10668 
        if ftype == TType.STRING:
10669 
          self.invoiceNumber = iprot.readString();
10670 
        else:
10671 
          iprot.skip(ftype)
10672 
      else:
10673 
        iprot.skip(ftype)
10674 
      iprot.readFieldEnd()
10675 
    iprot.readStructEnd()
10676 
 
10677 
  def write(self, oprot):
10678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10680 
      return
10681 
    oprot.writeStructBegin('addInvoiceNumber_args')
10682 
    if self.orderId is not None:
10683 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10684 
      oprot.writeI64(self.orderId)
10685 
      oprot.writeFieldEnd()
10686 
    if self.invoiceNumber is not None:
10687 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10688 
      oprot.writeString(self.invoiceNumber)
10689 
      oprot.writeFieldEnd()
10690 
    oprot.writeFieldStop()
10691 
    oprot.writeStructEnd()
10692 
 
10693 
  def validate(self):
10694 
    return
10695 
 
10696 
 
10697 
  def __repr__(self):
10698 
    L = ['%s=%r' % (key, value)
10699 
      for key, value in self.__dict__.iteritems()]
10700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10701 
 
10702 
  def __eq__(self, other):
10703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10704 
 
10705 
  def __ne__(self, other):
10706 
    return not (self == other)
10707 
 
10708 
class addInvoiceNumber_result:
10709 
  """
10710 
  Attributes:
10711 
   - ex
10712 
  """
10713 
 
10714 
  thrift_spec = (
10715 
    None, # 0
10716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10717 
  )
10718 
 
10719 
  def __init__(self, ex=None,):
10720 
    self.ex = ex
10721 
 
10722 
  def read(self, iprot):
10723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10725 
      return
10726 
    iprot.readStructBegin()
10727 
    while True:
10728 
      (fname, ftype, fid) = iprot.readFieldBegin()
10729 
      if ftype == TType.STOP:
10730 
        break
10731 
      if fid == 1:
10732 
        if ftype == TType.STRUCT:
10733 
          self.ex = TransactionServiceException()
10734 
          self.ex.read(iprot)
10735 
        else:
10736 
          iprot.skip(ftype)
10737 
      else:
10738 
        iprot.skip(ftype)
10739 
      iprot.readFieldEnd()
10740 
    iprot.readStructEnd()
10741 
 
10742 
  def write(self, oprot):
10743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10745 
      return
10746 
    oprot.writeStructBegin('addInvoiceNumber_result')
10747 
    if self.ex is not None:
10748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10749 
      self.ex.write(oprot)
10750 
      oprot.writeFieldEnd()
10751 
    oprot.writeFieldStop()
10752 
    oprot.writeStructEnd()
10753 
 
10754 
  def validate(self):
10755 
    return
10756 
 
10757 
 
10758 
  def __repr__(self):
10759 
    L = ['%s=%r' % (key, value)
10760 
      for key, value in self.__dict__.iteritems()]
10761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10762 
 
10763 
  def __eq__(self, other):
10764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10765 
 
10766 
  def __ne__(self, other):
10767 
    return not (self == other)
10768 
 
3064 chandransh 10769 
class markOrdersAsManifested_args:
1408 ankur.sing 10770 
  """
10771 
  Attributes:
3064 chandransh 10772 
   - warehouseId
1408 ankur.sing 10773 
   - providerId
3064 chandransh 10774 
   - cod
1408 ankur.sing 10775 
  """
10776 
 
10777 
  thrift_spec = (
10778 
    None, # 0
3064 chandransh 10779 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10780 
    (2, TType.I64, 'providerId', None, None, ), # 2
10781 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10782 
  )
10783 
 
3064 chandransh 10784 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10785 
    self.warehouseId = warehouseId
1408 ankur.sing 10786 
    self.providerId = providerId
3064 chandransh 10787 
    self.cod = cod
1408 ankur.sing 10788 
 
10789 
  def read(self, iprot):
10790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10792 
      return
10793 
    iprot.readStructBegin()
10794 
    while True:
10795 
      (fname, ftype, fid) = iprot.readFieldBegin()
10796 
      if ftype == TType.STOP:
10797 
        break
10798 
      if fid == 1:
10799 
        if ftype == TType.I64:
3064 chandransh 10800 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10801 
        else:
10802 
          iprot.skip(ftype)
10803 
      elif fid == 2:
10804 
        if ftype == TType.I64:
3064 chandransh 10805 
          self.providerId = iprot.readI64();
1408 ankur.sing 10806 
        else:
10807 
          iprot.skip(ftype)
3064 chandransh 10808 
      elif fid == 3:
10809 
        if ftype == TType.BOOL:
10810 
          self.cod = iprot.readBool();
10811 
        else:
10812 
          iprot.skip(ftype)
1408 ankur.sing 10813 
      else:
10814 
        iprot.skip(ftype)
10815 
      iprot.readFieldEnd()
10816 
    iprot.readStructEnd()
10817 
 
10818 
  def write(self, oprot):
10819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10821 
      return
3064 chandransh 10822 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10823 
    if self.warehouseId is not None:
3064 chandransh 10824 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10825 
      oprot.writeI64(self.warehouseId)
10826 
      oprot.writeFieldEnd()
3431 rajveer 10827 
    if self.providerId is not None:
3064 chandransh 10828 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10829 
      oprot.writeI64(self.providerId)
10830 
      oprot.writeFieldEnd()
3431 rajveer 10831 
    if self.cod is not None:
3064 chandransh 10832 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10833 
      oprot.writeBool(self.cod)
1408 ankur.sing 10834 
      oprot.writeFieldEnd()
10835 
    oprot.writeFieldStop()
10836 
    oprot.writeStructEnd()
10837 
 
3431 rajveer 10838 
  def validate(self):
10839 
    return
10840 
 
10841 
 
1408 ankur.sing 10842 
  def __repr__(self):
10843 
    L = ['%s=%r' % (key, value)
10844 
      for key, value in self.__dict__.iteritems()]
10845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10846 
 
10847 
  def __eq__(self, other):
10848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10849 
 
10850 
  def __ne__(self, other):
10851 
    return not (self == other)
10852 
 
3064 chandransh 10853 
class markOrdersAsManifested_result:
1408 ankur.sing 10854 
  """
10855 
  Attributes:
10856 
   - success
3064 chandransh 10857 
   - ex
1408 ankur.sing 10858 
  """
10859 
 
10860 
  thrift_spec = (
3064 chandransh 10861 
    (0, TType.BOOL, 'success', None, None, ), # 0
10862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10863 
  )
10864 
 
3064 chandransh 10865 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10866 
    self.success = success
3064 chandransh 10867 
    self.ex = ex
1408 ankur.sing 10868 
 
10869 
  def read(self, iprot):
10870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10872 
      return
10873 
    iprot.readStructBegin()
10874 
    while True:
10875 
      (fname, ftype, fid) = iprot.readFieldBegin()
10876 
      if ftype == TType.STOP:
10877 
        break
10878 
      if fid == 0:
3064 chandransh 10879 
        if ftype == TType.BOOL:
10880 
          self.success = iprot.readBool();
1408 ankur.sing 10881 
        else:
10882 
          iprot.skip(ftype)
3064 chandransh 10883 
      elif fid == 1:
10884 
        if ftype == TType.STRUCT:
10885 
          self.ex = TransactionServiceException()
10886 
          self.ex.read(iprot)
10887 
        else:
10888 
          iprot.skip(ftype)
1408 ankur.sing 10889 
      else:
10890 
        iprot.skip(ftype)
10891 
      iprot.readFieldEnd()
10892 
    iprot.readStructEnd()
10893 
 
10894 
  def write(self, oprot):
10895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10897 
      return
3064 chandransh 10898 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10899 
    if self.success is not None:
3064 chandransh 10900 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10901 
      oprot.writeBool(self.success)
1408 ankur.sing 10902 
      oprot.writeFieldEnd()
3431 rajveer 10903 
    if self.ex is not None:
3064 chandransh 10904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10905 
      self.ex.write(oprot)
10906 
      oprot.writeFieldEnd()
1408 ankur.sing 10907 
    oprot.writeFieldStop()
10908 
    oprot.writeStructEnd()
10909 
 
3431 rajveer 10910 
  def validate(self):
10911 
    return
10912 
 
10913 
 
1408 ankur.sing 10914 
  def __repr__(self):
10915 
    L = ['%s=%r' % (key, value)
10916 
      for key, value in self.__dict__.iteritems()]
10917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10918 
 
10919 
  def __eq__(self, other):
10920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10921 
 
10922 
  def __ne__(self, other):
10923 
    return not (self == other)
10924 
 
4410 rajveer 10925 
class markOrdersAsShippedFromWarehouse_args:
10926 
  """
10927 
  Attributes:
10928 
   - warehouseId
10929 
   - providerId
10930 
   - cod
10931 
  """
10932 
 
10933 
  thrift_spec = (
10934 
    None, # 0
10935 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10936 
    (2, TType.I64, 'providerId', None, None, ), # 2
10937 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10938 
  )
10939 
 
10940 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10941 
    self.warehouseId = warehouseId
10942 
    self.providerId = providerId
10943 
    self.cod = cod
10944 
 
10945 
  def read(self, iprot):
10946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10948 
      return
10949 
    iprot.readStructBegin()
10950 
    while True:
10951 
      (fname, ftype, fid) = iprot.readFieldBegin()
10952 
      if ftype == TType.STOP:
10953 
        break
10954 
      if fid == 1:
10955 
        if ftype == TType.I64:
10956 
          self.warehouseId = iprot.readI64();
10957 
        else:
10958 
          iprot.skip(ftype)
10959 
      elif fid == 2:
10960 
        if ftype == TType.I64:
10961 
          self.providerId = iprot.readI64();
10962 
        else:
10963 
          iprot.skip(ftype)
10964 
      elif fid == 3:
10965 
        if ftype == TType.BOOL:
10966 
          self.cod = iprot.readBool();
10967 
        else:
10968 
          iprot.skip(ftype)
10969 
      else:
10970 
        iprot.skip(ftype)
10971 
      iprot.readFieldEnd()
10972 
    iprot.readStructEnd()
10973 
 
10974 
  def write(self, oprot):
10975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10977 
      return
10978 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10979 
    if self.warehouseId is not None:
10980 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10981 
      oprot.writeI64(self.warehouseId)
10982 
      oprot.writeFieldEnd()
10983 
    if self.providerId is not None:
10984 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10985 
      oprot.writeI64(self.providerId)
10986 
      oprot.writeFieldEnd()
10987 
    if self.cod is not None:
10988 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10989 
      oprot.writeBool(self.cod)
10990 
      oprot.writeFieldEnd()
10991 
    oprot.writeFieldStop()
10992 
    oprot.writeStructEnd()
10993 
 
10994 
  def validate(self):
10995 
    return
10996 
 
10997 
 
10998 
  def __repr__(self):
10999 
    L = ['%s=%r' % (key, value)
11000 
      for key, value in self.__dict__.iteritems()]
11001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11002 
 
11003 
  def __eq__(self, other):
11004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11005 
 
11006 
  def __ne__(self, other):
11007 
    return not (self == other)
11008 
 
11009 
class markOrdersAsShippedFromWarehouse_result:
11010 
  """
11011 
  Attributes:
11012 
   - success
11013 
   - ex
11014 
  """
11015 
 
11016 
  thrift_spec = (
11017 
    (0, TType.BOOL, 'success', None, None, ), # 0
11018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11019 
  )
11020 
 
11021 
  def __init__(self, success=None, ex=None,):
11022 
    self.success = success
11023 
    self.ex = ex
11024 
 
11025 
  def read(self, iprot):
11026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11028 
      return
11029 
    iprot.readStructBegin()
11030 
    while True:
11031 
      (fname, ftype, fid) = iprot.readFieldBegin()
11032 
      if ftype == TType.STOP:
11033 
        break
11034 
      if fid == 0:
11035 
        if ftype == TType.BOOL:
11036 
          self.success = iprot.readBool();
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      elif fid == 1:
11040 
        if ftype == TType.STRUCT:
11041 
          self.ex = TransactionServiceException()
11042 
          self.ex.read(iprot)
11043 
        else:
11044 
          iprot.skip(ftype)
11045 
      else:
11046 
        iprot.skip(ftype)
11047 
      iprot.readFieldEnd()
11048 
    iprot.readStructEnd()
11049 
 
11050 
  def write(self, oprot):
11051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11053 
      return
11054 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11055 
    if self.success is not None:
11056 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11057 
      oprot.writeBool(self.success)
11058 
      oprot.writeFieldEnd()
11059 
    if self.ex is not None:
11060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11061 
      self.ex.write(oprot)
11062 
      oprot.writeFieldEnd()
11063 
    oprot.writeFieldStop()
11064 
    oprot.writeStructEnd()
11065 
 
11066 
  def validate(self):
11067 
    return
11068 
 
11069 
 
11070 
  def __repr__(self):
11071 
    L = ['%s=%r' % (key, value)
11072 
      for key, value in self.__dict__.iteritems()]
11073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11074 
 
11075 
  def __eq__(self, other):
11076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11077 
 
11078 
  def __ne__(self, other):
11079 
    return not (self == other)
11080 
 
3064 chandransh 11081 
class markOrdersAsPickedUp_args:
304 ashish 11082 
  """
11083 
  Attributes:
3064 chandransh 11084 
   - providerId
11085 
   - pickupDetails
304 ashish 11086 
  """
94 ashish 11087 
 
304 ashish 11088 
  thrift_spec = (
11089 
    None, # 0
3064 chandransh 11090 
    (1, TType.I64, 'providerId', None, None, ), # 1
11091 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11092 
  )
11093 
 
3064 chandransh 11094 
  def __init__(self, providerId=None, pickupDetails=None,):
11095 
    self.providerId = providerId
11096 
    self.pickupDetails = pickupDetails
304 ashish 11097 
 
11098 
  def read(self, iprot):
11099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11101 
      return
11102 
    iprot.readStructBegin()
11103 
    while True:
11104 
      (fname, ftype, fid) = iprot.readFieldBegin()
11105 
      if ftype == TType.STOP:
11106 
        break
11107 
      if fid == 1:
11108 
        if ftype == TType.I64:
3064 chandransh 11109 
          self.providerId = iprot.readI64();
304 ashish 11110 
        else:
11111 
          iprot.skip(ftype)
11112 
      elif fid == 2:
3064 chandransh 11113 
        if ftype == TType.MAP:
11114 
          self.pickupDetails = {}
4133 chandransh 11115 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
11116 
          for _i144 in xrange(_size140):
11117 
            _key145 = iprot.readString();
11118 
            _val146 = iprot.readString();
11119 
            self.pickupDetails[_key145] = _val146
3064 chandransh 11120 
          iprot.readMapEnd()
304 ashish 11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
3064 chandransh 11132 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11133 
    if self.providerId is not None:
3064 chandransh 11134 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11135 
      oprot.writeI64(self.providerId)
304 ashish 11136 
      oprot.writeFieldEnd()
3431 rajveer 11137 
    if self.pickupDetails is not None:
3064 chandransh 11138 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11139 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11140 
      for kiter147,viter148 in self.pickupDetails.items():
11141 
        oprot.writeString(kiter147)
11142 
        oprot.writeString(viter148)
3064 chandransh 11143 
      oprot.writeMapEnd()
304 ashish 11144 
      oprot.writeFieldEnd()
11145 
    oprot.writeFieldStop()
11146 
    oprot.writeStructEnd()
11147 
 
3431 rajveer 11148 
  def validate(self):
11149 
    return
11150 
 
11151 
 
304 ashish 11152 
  def __repr__(self):
11153 
    L = ['%s=%r' % (key, value)
11154 
      for key, value in self.__dict__.iteritems()]
11155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11156 
 
11157 
  def __eq__(self, other):
11158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11159 
 
11160 
  def __ne__(self, other):
11161 
    return not (self == other)
11162 
 
3064 chandransh 11163 
class markOrdersAsPickedUp_result:
304 ashish 11164 
  """
11165 
  Attributes:
11166 
   - success
3064 chandransh 11167 
   - ex
304 ashish 11168 
  """
11169 
 
11170 
  thrift_spec = (
3064 chandransh 11171 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11173 
  )
11174 
 
3064 chandransh 11175 
  def __init__(self, success=None, ex=None,):
304 ashish 11176 
    self.success = success
3064 chandransh 11177 
    self.ex = ex
304 ashish 11178 
 
11179 
  def read(self, iprot):
11180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11182 
      return
11183 
    iprot.readStructBegin()
11184 
    while True:
11185 
      (fname, ftype, fid) = iprot.readFieldBegin()
11186 
      if ftype == TType.STOP:
11187 
        break
11188 
      if fid == 0:
11189 
        if ftype == TType.LIST:
11190 
          self.success = []
4133 chandransh 11191 
          (_etype152, _size149) = iprot.readListBegin()
11192 
          for _i153 in xrange(_size149):
11193 
            _elem154 = Order()
11194 
            _elem154.read(iprot)
11195 
            self.success.append(_elem154)
304 ashish 11196 
          iprot.readListEnd()
11197 
        else:
11198 
          iprot.skip(ftype)
3064 chandransh 11199 
      elif fid == 1:
11200 
        if ftype == TType.STRUCT:
11201 
          self.ex = TransactionServiceException()
11202 
          self.ex.read(iprot)
11203 
        else:
11204 
          iprot.skip(ftype)
304 ashish 11205 
      else:
11206 
        iprot.skip(ftype)
11207 
      iprot.readFieldEnd()
11208 
    iprot.readStructEnd()
11209 
 
11210 
  def write(self, oprot):
11211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11213 
      return
3064 chandransh 11214 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11215 
    if self.success is not None:
304 ashish 11216 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11217 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11218 
      for iter155 in self.success:
11219 
        iter155.write(oprot)
304 ashish 11220 
      oprot.writeListEnd()
11221 
      oprot.writeFieldEnd()
3431 rajveer 11222 
    if self.ex is not None:
3064 chandransh 11223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11224 
      self.ex.write(oprot)
11225 
      oprot.writeFieldEnd()
304 ashish 11226 
    oprot.writeFieldStop()
11227 
    oprot.writeStructEnd()
11228 
 
3431 rajveer 11229 
  def validate(self):
11230 
    return
11231 
 
11232 
 
304 ashish 11233 
  def __repr__(self):
11234 
    L = ['%s=%r' % (key, value)
11235 
      for key, value in self.__dict__.iteritems()]
11236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11237 
 
11238 
  def __eq__(self, other):
11239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11240 
 
11241 
  def __ne__(self, other):
11242 
    return not (self == other)
11243 
 
3064 chandransh 11244 
class markOrdersAsDelivered_args:
304 ashish 11245 
  """
11246 
  Attributes:
3064 chandransh 11247 
   - providerId
11248 
   - deliveredOrders
304 ashish 11249 
  """
11250 
 
11251 
  thrift_spec = (
11252 
    None, # 0
3064 chandransh 11253 
    (1, TType.I64, 'providerId', None, None, ), # 1
11254 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11255 
  )
11256 
 
3064 chandransh 11257 
  def __init__(self, providerId=None, deliveredOrders=None,):
11258 
    self.providerId = providerId
11259 
    self.deliveredOrders = deliveredOrders
304 ashish 11260 
 
11261 
  def read(self, iprot):
11262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11264 
      return
11265 
    iprot.readStructBegin()
11266 
    while True:
11267 
      (fname, ftype, fid) = iprot.readFieldBegin()
11268 
      if ftype == TType.STOP:
11269 
        break
11270 
      if fid == 1:
11271 
        if ftype == TType.I64:
3064 chandransh 11272 
          self.providerId = iprot.readI64();
304 ashish 11273 
        else:
11274 
          iprot.skip(ftype)
11275 
      elif fid == 2:
3064 chandransh 11276 
        if ftype == TType.MAP:
11277 
          self.deliveredOrders = {}
4133 chandransh 11278 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11279 
          for _i160 in xrange(_size156):
11280 
            _key161 = iprot.readString();
11281 
            _val162 = iprot.readString();
11282 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11283 
          iprot.readMapEnd()
304 ashish 11284 
        else:
11285 
          iprot.skip(ftype)
11286 
      else:
11287 
        iprot.skip(ftype)
11288 
      iprot.readFieldEnd()
11289 
    iprot.readStructEnd()
11290 
 
11291 
  def write(self, oprot):
11292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11294 
      return
3064 chandransh 11295 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11296 
    if self.providerId is not None:
3064 chandransh 11297 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11298 
      oprot.writeI64(self.providerId)
304 ashish 11299 
      oprot.writeFieldEnd()
3431 rajveer 11300 
    if self.deliveredOrders is not None:
3064 chandransh 11301 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11302 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11303 
      for kiter163,viter164 in self.deliveredOrders.items():
11304 
        oprot.writeString(kiter163)
11305 
        oprot.writeString(viter164)
3064 chandransh 11306 
      oprot.writeMapEnd()
304 ashish 11307 
      oprot.writeFieldEnd()
11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
3431 rajveer 11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
304 ashish 11315 
  def __repr__(self):
11316 
    L = ['%s=%r' % (key, value)
11317 
      for key, value in self.__dict__.iteritems()]
11318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11319 
 
11320 
  def __eq__(self, other):
11321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11322 
 
11323 
  def __ne__(self, other):
11324 
    return not (self == other)
11325 
 
3064 chandransh 11326 
class markOrdersAsDelivered_result:
11327 
  """
11328 
  Attributes:
11329 
   - ex
11330 
  """
304 ashish 11331 
 
11332 
  thrift_spec = (
3064 chandransh 11333 
    None, # 0
11334 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11335 
  )
11336 
 
3064 chandransh 11337 
  def __init__(self, ex=None,):
11338 
    self.ex = ex
304 ashish 11339 
 
1596 ankur.sing 11340 
  def read(self, iprot):
11341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11343 
      return
11344 
    iprot.readStructBegin()
11345 
    while True:
11346 
      (fname, ftype, fid) = iprot.readFieldBegin()
11347 
      if ftype == TType.STOP:
11348 
        break
3064 chandransh 11349 
      if fid == 1:
11350 
        if ftype == TType.STRUCT:
11351 
          self.ex = TransactionServiceException()
11352 
          self.ex.read(iprot)
11353 
        else:
11354 
          iprot.skip(ftype)
1596 ankur.sing 11355 
      else:
11356 
        iprot.skip(ftype)
11357 
      iprot.readFieldEnd()
11358 
    iprot.readStructEnd()
11359 
 
11360 
  def write(self, oprot):
11361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11363 
      return
3064 chandransh 11364 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11365 
    if self.ex is not None:
3064 chandransh 11366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11367 
      self.ex.write(oprot)
11368 
      oprot.writeFieldEnd()
1596 ankur.sing 11369 
    oprot.writeFieldStop()
11370 
    oprot.writeStructEnd()
11371 
 
3431 rajveer 11372 
  def validate(self):
11373 
    return
11374 
 
11375 
 
1596 ankur.sing 11376 
  def __repr__(self):
11377 
    L = ['%s=%r' % (key, value)
11378 
      for key, value in self.__dict__.iteritems()]
11379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11380 
 
11381 
  def __eq__(self, other):
11382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11383 
 
11384 
  def __ne__(self, other):
11385 
    return not (self == other)
11386 
 
3064 chandransh 11387 
class markOrdersAsFailed_args:
1596 ankur.sing 11388 
  """
11389 
  Attributes:
3064 chandransh 11390 
   - providerId
11391 
   - returnedOrders
1596 ankur.sing 11392 
  """
11393 
 
11394 
  thrift_spec = (
3064 chandransh 11395 
    None, # 0
11396 
    (1, TType.I64, 'providerId', None, None, ), # 1
11397 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11398 
  )
11399 
 
3064 chandransh 11400 
  def __init__(self, providerId=None, returnedOrders=None,):
11401 
    self.providerId = providerId
11402 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11403 
 
11404 
  def read(self, iprot):
11405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11407 
      return
11408 
    iprot.readStructBegin()
11409 
    while True:
11410 
      (fname, ftype, fid) = iprot.readFieldBegin()
11411 
      if ftype == TType.STOP:
11412 
        break
3064 chandransh 11413 
      if fid == 1:
1596 ankur.sing 11414 
        if ftype == TType.I64:
3064 chandransh 11415 
          self.providerId = iprot.readI64();
1596 ankur.sing 11416 
        else:
11417 
          iprot.skip(ftype)
3064 chandransh 11418 
      elif fid == 2:
11419 
        if ftype == TType.MAP:
11420 
          self.returnedOrders = {}
4133 chandransh 11421 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11422 
          for _i169 in xrange(_size165):
11423 
            _key170 = iprot.readString();
11424 
            _val171 = iprot.readString();
11425 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11426 
          iprot.readMapEnd()
11427 
        else:
11428 
          iprot.skip(ftype)
1596 ankur.sing 11429 
      else:
11430 
        iprot.skip(ftype)
11431 
      iprot.readFieldEnd()
11432 
    iprot.readStructEnd()
11433 
 
11434 
  def write(self, oprot):
11435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11437 
      return
3064 chandransh 11438 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11439 
    if self.providerId is not None:
3064 chandransh 11440 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11441 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11442 
      oprot.writeFieldEnd()
3431 rajveer 11443 
    if self.returnedOrders is not None:
3064 chandransh 11444 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11445 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11446 
      for kiter172,viter173 in self.returnedOrders.items():
11447 
        oprot.writeString(kiter172)
11448 
        oprot.writeString(viter173)
3064 chandransh 11449 
      oprot.writeMapEnd()
11450 
      oprot.writeFieldEnd()
1596 ankur.sing 11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
3431 rajveer 11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
1596 ankur.sing 11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
3064 chandransh 11469 
class markOrdersAsFailed_result:
11470 
  """
11471 
  Attributes:
11472 
   - ex
11473 
  """
1596 ankur.sing 11474 
 
1627 ankur.sing 11475 
  thrift_spec = (
3064 chandransh 11476 
    None, # 0
11477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11478 
  )
11479 
 
3064 chandransh 11480 
  def __init__(self, ex=None,):
11481 
    self.ex = ex
11482 
 
1627 ankur.sing 11483 
  def read(self, iprot):
11484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11486 
      return
11487 
    iprot.readStructBegin()
11488 
    while True:
11489 
      (fname, ftype, fid) = iprot.readFieldBegin()
11490 
      if ftype == TType.STOP:
11491 
        break
3064 chandransh 11492 
      if fid == 1:
11493 
        if ftype == TType.STRUCT:
11494 
          self.ex = TransactionServiceException()
11495 
          self.ex.read(iprot)
11496 
        else:
11497 
          iprot.skip(ftype)
1627 ankur.sing 11498 
      else:
11499 
        iprot.skip(ftype)
11500 
      iprot.readFieldEnd()
11501 
    iprot.readStructEnd()
11502 
 
11503 
  def write(self, oprot):
11504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11506 
      return
3064 chandransh 11507 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11508 
    if self.ex is not None:
3064 chandransh 11509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11510 
      self.ex.write(oprot)
11511 
      oprot.writeFieldEnd()
1627 ankur.sing 11512 
    oprot.writeFieldStop()
11513 
    oprot.writeStructEnd()
11514 
 
3431 rajveer 11515 
  def validate(self):
11516 
    return
11517 
 
11518 
 
1627 ankur.sing 11519 
  def __repr__(self):
11520 
    L = ['%s=%r' % (key, value)
11521 
      for key, value in self.__dict__.iteritems()]
11522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11523 
 
11524 
  def __eq__(self, other):
11525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11526 
 
11527 
  def __ne__(self, other):
11528 
    return not (self == other)
11529 
 
3064 chandransh 11530 
class updateNonDeliveryReason_args:
1627 ankur.sing 11531 
  """
11532 
  Attributes:
3064 chandransh 11533 
   - providerId
11534 
   - undeliveredOrders
1627 ankur.sing 11535 
  """
11536 
 
11537 
  thrift_spec = (
3064 chandransh 11538 
    None, # 0
11539 
    (1, TType.I64, 'providerId', None, None, ), # 1
11540 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11541 
  )
11542 
 
3064 chandransh 11543 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11544 
    self.providerId = providerId
11545 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11546 
 
11547 
  def read(self, iprot):
11548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11550 
      return
11551 
    iprot.readStructBegin()
11552 
    while True:
11553 
      (fname, ftype, fid) = iprot.readFieldBegin()
11554 
      if ftype == TType.STOP:
11555 
        break
3064 chandransh 11556 
      if fid == 1:
1627 ankur.sing 11557 
        if ftype == TType.I64:
3064 chandransh 11558 
          self.providerId = iprot.readI64();
1627 ankur.sing 11559 
        else:
11560 
          iprot.skip(ftype)
3064 chandransh 11561 
      elif fid == 2:
11562 
        if ftype == TType.MAP:
11563 
          self.undeliveredOrders = {}
4133 chandransh 11564 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11565 
          for _i178 in xrange(_size174):
11566 
            _key179 = iprot.readString();
11567 
            _val180 = iprot.readString();
11568 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11569 
          iprot.readMapEnd()
11570 
        else:
11571 
          iprot.skip(ftype)
1627 ankur.sing 11572 
      else:
11573 
        iprot.skip(ftype)
11574 
      iprot.readFieldEnd()
11575 
    iprot.readStructEnd()
11576 
 
11577 
  def write(self, oprot):
11578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11580 
      return
3064 chandransh 11581 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11582 
    if self.providerId is not None:
3064 chandransh 11583 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11584 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11585 
      oprot.writeFieldEnd()
3431 rajveer 11586 
    if self.undeliveredOrders is not None:
3064 chandransh 11587 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11588 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11589 
      for kiter181,viter182 in self.undeliveredOrders.items():
11590 
        oprot.writeString(kiter181)
11591 
        oprot.writeString(viter182)
3064 chandransh 11592 
      oprot.writeMapEnd()
11593 
      oprot.writeFieldEnd()
1627 ankur.sing 11594 
    oprot.writeFieldStop()
11595 
    oprot.writeStructEnd()
11596 
 
3431 rajveer 11597 
  def validate(self):
11598 
    return
11599 
 
11600 
 
1627 ankur.sing 11601 
  def __repr__(self):
11602 
    L = ['%s=%r' % (key, value)
11603 
      for key, value in self.__dict__.iteritems()]
11604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11605 
 
11606 
  def __eq__(self, other):
11607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11608 
 
11609 
  def __ne__(self, other):
11610 
    return not (self == other)
11611 
 
3064 chandransh 11612 
class updateNonDeliveryReason_result:
1627 ankur.sing 11613 
  """
11614 
  Attributes:
4581 phani.kuma 11615 
   - success
3064 chandransh 11616 
   - ex
1627 ankur.sing 11617 
  """
11618 
 
11619 
  thrift_spec = (
4581 phani.kuma 11620 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11622 
  )
11623 
 
4581 phani.kuma 11624 
  def __init__(self, success=None, ex=None,):
11625 
    self.success = success
3064 chandransh 11626 
    self.ex = ex
1627 ankur.sing 11627 
 
11628 
  def read(self, iprot):
11629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11631 
      return
11632 
    iprot.readStructBegin()
11633 
    while True:
11634 
      (fname, ftype, fid) = iprot.readFieldBegin()
11635 
      if ftype == TType.STOP:
11636 
        break
4581 phani.kuma 11637 
      if fid == 0:
11638 
        if ftype == TType.LIST:
11639 
          self.success = []
11640 
          (_etype186, _size183) = iprot.readListBegin()
11641 
          for _i187 in xrange(_size183):
11642 
            _elem188 = Order()
11643 
            _elem188.read(iprot)
11644 
            self.success.append(_elem188)
11645 
          iprot.readListEnd()
11646 
        else:
11647 
          iprot.skip(ftype)
11648 
      elif fid == 1:
3064 chandransh 11649 
        if ftype == TType.STRUCT:
11650 
          self.ex = TransactionServiceException()
11651 
          self.ex.read(iprot)
1627 ankur.sing 11652 
        else:
11653 
          iprot.skip(ftype)
11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
3064 chandransh 11663 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11664 
    if self.success is not None:
11665 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11666 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11667 
      for iter189 in self.success:
11668 
        iter189.write(oprot)
11669 
      oprot.writeListEnd()
11670 
      oprot.writeFieldEnd()
3431 rajveer 11671 
    if self.ex is not None:
3064 chandransh 11672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11673 
      self.ex.write(oprot)
1627 ankur.sing 11674 
      oprot.writeFieldEnd()
11675 
    oprot.writeFieldStop()
11676 
    oprot.writeStructEnd()
11677 
 
3431 rajveer 11678 
  def validate(self):
11679 
    return
11680 
 
11681 
 
1627 ankur.sing 11682 
  def __repr__(self):
11683 
    L = ['%s=%r' % (key, value)
11684 
      for key, value in self.__dict__.iteritems()]
11685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11686 
 
11687 
  def __eq__(self, other):
11688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11689 
 
11690 
  def __ne__(self, other):
11691 
    return not (self == other)
11692 
 
3064 chandransh 11693 
class getUndeliveredOrders_args:
1886 ankur.sing 11694 
  """
11695 
  Attributes:
3064 chandransh 11696 
   - providerId
11697 
   - warehouseId
1886 ankur.sing 11698 
  """
1627 ankur.sing 11699 
 
1886 ankur.sing 11700 
  thrift_spec = (
11701 
    None, # 0
3064 chandransh 11702 
    (1, TType.I64, 'providerId', None, None, ), # 1
11703 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11704 
  )
11705 
 
3064 chandransh 11706 
  def __init__(self, providerId=None, warehouseId=None,):
11707 
    self.providerId = providerId
11708 
    self.warehouseId = warehouseId
1886 ankur.sing 11709 
 
11710 
  def read(self, iprot):
11711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11713 
      return
11714 
    iprot.readStructBegin()
11715 
    while True:
11716 
      (fname, ftype, fid) = iprot.readFieldBegin()
11717 
      if ftype == TType.STOP:
11718 
        break
11719 
      if fid == 1:
11720 
        if ftype == TType.I64:
3064 chandransh 11721 
          self.providerId = iprot.readI64();
1886 ankur.sing 11722 
        else:
11723 
          iprot.skip(ftype)
3064 chandransh 11724 
      elif fid == 2:
11725 
        if ftype == TType.I64:
11726 
          self.warehouseId = iprot.readI64();
11727 
        else:
11728 
          iprot.skip(ftype)
1886 ankur.sing 11729 
      else:
11730 
        iprot.skip(ftype)
11731 
      iprot.readFieldEnd()
11732 
    iprot.readStructEnd()
11733 
 
11734 
  def write(self, oprot):
11735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11737 
      return
3064 chandransh 11738 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11739 
    if self.providerId is not None:
3064 chandransh 11740 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11741 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11742 
      oprot.writeFieldEnd()
3431 rajveer 11743 
    if self.warehouseId is not None:
3064 chandransh 11744 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11745 
      oprot.writeI64(self.warehouseId)
11746 
      oprot.writeFieldEnd()
1886 ankur.sing 11747 
    oprot.writeFieldStop()
11748 
    oprot.writeStructEnd()
11749 
 
3431 rajveer 11750 
  def validate(self):
11751 
    return
11752 
 
11753 
 
1886 ankur.sing 11754 
  def __repr__(self):
11755 
    L = ['%s=%r' % (key, value)
11756 
      for key, value in self.__dict__.iteritems()]
11757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11758 
 
11759 
  def __eq__(self, other):
11760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11761 
 
11762 
  def __ne__(self, other):
11763 
    return not (self == other)
11764 
 
3064 chandransh 11765 
class getUndeliveredOrders_result:
1886 ankur.sing 11766 
  """
11767 
  Attributes:
11768 
   - success
11769 
  """
11770 
 
11771 
  thrift_spec = (
11772 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11773 
  )
11774 
 
11775 
  def __init__(self, success=None,):
11776 
    self.success = success
11777 
 
11778 
  def read(self, iprot):
11779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11781 
      return
11782 
    iprot.readStructBegin()
11783 
    while True:
11784 
      (fname, ftype, fid) = iprot.readFieldBegin()
11785 
      if ftype == TType.STOP:
11786 
        break
11787 
      if fid == 0:
11788 
        if ftype == TType.LIST:
11789 
          self.success = []
4581 phani.kuma 11790 
          (_etype193, _size190) = iprot.readListBegin()
11791 
          for _i194 in xrange(_size190):
11792 
            _elem195 = Order()
11793 
            _elem195.read(iprot)
11794 
            self.success.append(_elem195)
1886 ankur.sing 11795 
          iprot.readListEnd()
11796 
        else:
11797 
          iprot.skip(ftype)
11798 
      else:
11799 
        iprot.skip(ftype)
11800 
      iprot.readFieldEnd()
11801 
    iprot.readStructEnd()
11802 
 
11803 
  def write(self, oprot):
11804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11806 
      return
3064 chandransh 11807 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11808 
    if self.success is not None:
1886 ankur.sing 11809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11811 
      for iter196 in self.success:
11812 
        iter196.write(oprot)
1886 ankur.sing 11813 
      oprot.writeListEnd()
11814 
      oprot.writeFieldEnd()
11815 
    oprot.writeFieldStop()
11816 
    oprot.writeStructEnd()
11817 
 
3431 rajveer 11818 
  def validate(self):
11819 
    return
11820 
 
11821 
 
1886 ankur.sing 11822 
  def __repr__(self):
11823 
    L = ['%s=%r' % (key, value)
11824 
      for key, value in self.__dict__.iteritems()]
11825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11826 
 
11827 
  def __eq__(self, other):
11828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11829 
 
11830 
  def __ne__(self, other):
11831 
    return not (self == other)
11832 
 
2536 chandransh 11833 
class toggleDOAFlag_args:
11834 
  """
11835 
  Attributes:
11836 
   - orderId
11837 
  """
1886 ankur.sing 11838 
 
2536 chandransh 11839 
  thrift_spec = (
11840 
    None, # 0
11841 
    (1, TType.I64, 'orderId', None, None, ), # 1
11842 
  )
11843 
 
11844 
  def __init__(self, orderId=None,):
11845 
    self.orderId = orderId
11846 
 
11847 
  def read(self, iprot):
11848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11850 
      return
11851 
    iprot.readStructBegin()
11852 
    while True:
11853 
      (fname, ftype, fid) = iprot.readFieldBegin()
11854 
      if ftype == TType.STOP:
11855 
        break
11856 
      if fid == 1:
11857 
        if ftype == TType.I64:
11858 
          self.orderId = iprot.readI64();
11859 
        else:
11860 
          iprot.skip(ftype)
11861 
      else:
11862 
        iprot.skip(ftype)
11863 
      iprot.readFieldEnd()
11864 
    iprot.readStructEnd()
11865 
 
11866 
  def write(self, oprot):
11867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11869 
      return
11870 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11871 
    if self.orderId is not None:
2536 chandransh 11872 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11873 
      oprot.writeI64(self.orderId)
11874 
      oprot.writeFieldEnd()
11875 
    oprot.writeFieldStop()
11876 
    oprot.writeStructEnd()
11877 
 
3431 rajveer 11878 
  def validate(self):
11879 
    return
11880 
 
11881 
 
2536 chandransh 11882 
  def __repr__(self):
11883 
    L = ['%s=%r' % (key, value)
11884 
      for key, value in self.__dict__.iteritems()]
11885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11886 
 
11887 
  def __eq__(self, other):
11888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11889 
 
11890 
  def __ne__(self, other):
11891 
    return not (self == other)
11892 
 
11893 
class toggleDOAFlag_result:
11894 
  """
11895 
  Attributes:
11896 
   - success
11897 
   - ex
11898 
  """
11899 
 
11900 
  thrift_spec = (
11901 
    (0, TType.BOOL, 'success', None, None, ), # 0
11902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11903 
  )
11904 
 
11905 
  def __init__(self, success=None, ex=None,):
11906 
    self.success = success
11907 
    self.ex = ex
11908 
 
11909 
  def read(self, iprot):
11910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11912 
      return
11913 
    iprot.readStructBegin()
11914 
    while True:
11915 
      (fname, ftype, fid) = iprot.readFieldBegin()
11916 
      if ftype == TType.STOP:
11917 
        break
11918 
      if fid == 0:
11919 
        if ftype == TType.BOOL:
11920 
          self.success = iprot.readBool();
11921 
        else:
11922 
          iprot.skip(ftype)
11923 
      elif fid == 1:
11924 
        if ftype == TType.STRUCT:
11925 
          self.ex = TransactionServiceException()
11926 
          self.ex.read(iprot)
11927 
        else:
11928 
          iprot.skip(ftype)
11929 
      else:
11930 
        iprot.skip(ftype)
11931 
      iprot.readFieldEnd()
11932 
    iprot.readStructEnd()
11933 
 
11934 
  def write(self, oprot):
11935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11937 
      return
11938 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11939 
    if self.success is not None:
2536 chandransh 11940 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11941 
      oprot.writeBool(self.success)
11942 
      oprot.writeFieldEnd()
3431 rajveer 11943 
    if self.ex is not None:
2536 chandransh 11944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11945 
      self.ex.write(oprot)
11946 
      oprot.writeFieldEnd()
11947 
    oprot.writeFieldStop()
11948 
    oprot.writeStructEnd()
11949 
 
3431 rajveer 11950 
  def validate(self):
11951 
    return
11952 
 
11953 
 
2536 chandransh 11954 
  def __repr__(self):
11955 
    L = ['%s=%r' % (key, value)
11956 
      for key, value in self.__dict__.iteritems()]
11957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11958 
 
11959 
  def __eq__(self, other):
11960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11961 
 
11962 
  def __ne__(self, other):
11963 
    return not (self == other)
11964 
 
4712 rajveer 11965 
class markOrderAsDelivered_args:
11966 
  """
11967 
  Attributes:
11968 
   - orderId
11969 
   - deliveryTimestamp
11970 
   - receiver
11971 
  """
11972 
 
11973 
  thrift_spec = None
11974 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
11975 
    self.orderId = orderId
11976 
    self.deliveryTimestamp = deliveryTimestamp
11977 
    self.receiver = receiver
11978 
 
11979 
  def read(self, iprot):
11980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11982 
      return
11983 
    iprot.readStructBegin()
11984 
    while True:
11985 
      (fname, ftype, fid) = iprot.readFieldBegin()
11986 
      if ftype == TType.STOP:
11987 
        break
11988 
      if fid == 1:
11989 
        if ftype == TType.I64:
11990 
          self.orderId = iprot.readI64();
11991 
        else:
11992 
          iprot.skip(ftype)
11993 
      elif fid == 2:
11994 
        if ftype == TType.I64:
11995 
          self.deliveryTimestamp = iprot.readI64();
11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      elif fid == -1:
11999 
        if ftype == TType.STRING:
12000 
          self.receiver = iprot.readString();
12001 
        else:
12002 
          iprot.skip(ftype)
12003 
      else:
12004 
        iprot.skip(ftype)
12005 
      iprot.readFieldEnd()
12006 
    iprot.readStructEnd()
12007 
 
12008 
  def write(self, oprot):
12009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12011 
      return
12012 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12013 
    if self.receiver is not None:
12014 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12015 
      oprot.writeString(self.receiver)
12016 
      oprot.writeFieldEnd()
12017 
    if self.orderId is not None:
12018 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12019 
      oprot.writeI64(self.orderId)
12020 
      oprot.writeFieldEnd()
12021 
    if self.deliveryTimestamp is not None:
12022 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12023 
      oprot.writeI64(self.deliveryTimestamp)
12024 
      oprot.writeFieldEnd()
12025 
    oprot.writeFieldStop()
12026 
    oprot.writeStructEnd()
12027 
 
12028 
  def validate(self):
12029 
    return
12030 
 
12031 
 
12032 
  def __repr__(self):
12033 
    L = ['%s=%r' % (key, value)
12034 
      for key, value in self.__dict__.iteritems()]
12035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12036 
 
12037 
  def __eq__(self, other):
12038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12039 
 
12040 
  def __ne__(self, other):
12041 
    return not (self == other)
12042 
 
12043 
class markOrderAsDelivered_result:
12044 
  """
12045 
  Attributes:
12046 
   - ex
12047 
  """
12048 
 
12049 
  thrift_spec = (
12050 
    None, # 0
12051 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12052 
  )
12053 
 
12054 
  def __init__(self, ex=None,):
12055 
    self.ex = ex
12056 
 
12057 
  def read(self, iprot):
12058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12060 
      return
12061 
    iprot.readStructBegin()
12062 
    while True:
12063 
      (fname, ftype, fid) = iprot.readFieldBegin()
12064 
      if ftype == TType.STOP:
12065 
        break
12066 
      if fid == 1:
12067 
        if ftype == TType.STRUCT:
12068 
          self.ex = TransactionServiceException()
12069 
          self.ex.read(iprot)
12070 
        else:
12071 
          iprot.skip(ftype)
12072 
      else:
12073 
        iprot.skip(ftype)
12074 
      iprot.readFieldEnd()
12075 
    iprot.readStructEnd()
12076 
 
12077 
  def write(self, oprot):
12078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12080 
      return
12081 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12082 
    if self.ex is not None:
12083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12084 
      self.ex.write(oprot)
12085 
      oprot.writeFieldEnd()
12086 
    oprot.writeFieldStop()
12087 
    oprot.writeStructEnd()
12088 
 
12089 
  def validate(self):
12090 
    return
12091 
 
12092 
 
12093 
  def __repr__(self):
12094 
    L = ['%s=%r' % (key, value)
12095 
      for key, value in self.__dict__.iteritems()]
12096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12097 
 
12098 
  def __eq__(self, other):
12099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12100 
 
12101 
  def __ne__(self, other):
12102 
    return not (self == other)
12103 
 
4454 rajveer 12104 
class markOrderDoaRequestReceived_args:
12105 
  """
12106 
  Attributes:
12107 
   - orderId
12108 
  """
12109 
 
12110 
  thrift_spec = (
12111 
    None, # 0
12112 
    (1, TType.I64, 'orderId', None, None, ), # 1
12113 
  )
12114 
 
12115 
  def __init__(self, orderId=None,):
12116 
    self.orderId = orderId
12117 
 
12118 
  def read(self, iprot):
12119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12121 
      return
12122 
    iprot.readStructBegin()
12123 
    while True:
12124 
      (fname, ftype, fid) = iprot.readFieldBegin()
12125 
      if ftype == TType.STOP:
12126 
        break
12127 
      if fid == 1:
12128 
        if ftype == TType.I64:
12129 
          self.orderId = iprot.readI64();
12130 
        else:
12131 
          iprot.skip(ftype)
12132 
      else:
12133 
        iprot.skip(ftype)
12134 
      iprot.readFieldEnd()
12135 
    iprot.readStructEnd()
12136 
 
12137 
  def write(self, oprot):
12138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12140 
      return
12141 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12142 
    if self.orderId is not None:
12143 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12144 
      oprot.writeI64(self.orderId)
12145 
      oprot.writeFieldEnd()
12146 
    oprot.writeFieldStop()
12147 
    oprot.writeStructEnd()
12148 
 
12149 
  def validate(self):
12150 
    return
12151 
 
12152 
 
12153 
  def __repr__(self):
12154 
    L = ['%s=%r' % (key, value)
12155 
      for key, value in self.__dict__.iteritems()]
12156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12157 
 
12158 
  def __eq__(self, other):
12159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12160 
 
12161 
  def __ne__(self, other):
12162 
    return not (self == other)
12163 
 
12164 
class markOrderDoaRequestReceived_result:
12165 
  """
12166 
  Attributes:
12167 
   - success
12168 
   - ex
12169 
  """
12170 
 
12171 
  thrift_spec = (
12172 
    (0, TType.BOOL, 'success', None, None, ), # 0
12173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12174 
  )
12175 
 
12176 
  def __init__(self, success=None, ex=None,):
12177 
    self.success = success
12178 
    self.ex = ex
12179 
 
12180 
  def read(self, iprot):
12181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12183 
      return
12184 
    iprot.readStructBegin()
12185 
    while True:
12186 
      (fname, ftype, fid) = iprot.readFieldBegin()
12187 
      if ftype == TType.STOP:
12188 
        break
12189 
      if fid == 0:
12190 
        if ftype == TType.BOOL:
12191 
          self.success = iprot.readBool();
12192 
        else:
12193 
          iprot.skip(ftype)
12194 
      elif fid == 1:
12195 
        if ftype == TType.STRUCT:
12196 
          self.ex = TransactionServiceException()
12197 
          self.ex.read(iprot)
12198 
        else:
12199 
          iprot.skip(ftype)
12200 
      else:
12201 
        iprot.skip(ftype)
12202 
      iprot.readFieldEnd()
12203 
    iprot.readStructEnd()
12204 
 
12205 
  def write(self, oprot):
12206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12208 
      return
12209 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12210 
    if self.success is not None:
12211 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12212 
      oprot.writeBool(self.success)
12213 
      oprot.writeFieldEnd()
12214 
    if self.ex is not None:
12215 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12216 
      self.ex.write(oprot)
12217 
      oprot.writeFieldEnd()
12218 
    oprot.writeFieldStop()
12219 
    oprot.writeStructEnd()
12220 
 
12221 
  def validate(self):
12222 
    return
12223 
 
12224 
 
12225 
  def __repr__(self):
12226 
    L = ['%s=%r' % (key, value)
12227 
      for key, value in self.__dict__.iteritems()]
12228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12229 
 
12230 
  def __eq__(self, other):
12231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12232 
 
12233 
  def __ne__(self, other):
12234 
    return not (self == other)
12235 
 
12236 
class markOrderDoaRequestAuthorized_args:
12237 
  """
12238 
  Attributes:
12239 
   - orderId
12240 
   - isAuthorized
12241 
  """
12242 
 
12243 
  thrift_spec = (
12244 
    None, # 0
12245 
    (1, TType.I64, 'orderId', None, None, ), # 1
12246 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12247 
  )
12248 
 
12249 
  def __init__(self, orderId=None, isAuthorized=None,):
12250 
    self.orderId = orderId
12251 
    self.isAuthorized = isAuthorized
12252 
 
12253 
  def read(self, iprot):
12254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12256 
      return
12257 
    iprot.readStructBegin()
12258 
    while True:
12259 
      (fname, ftype, fid) = iprot.readFieldBegin()
12260 
      if ftype == TType.STOP:
12261 
        break
12262 
      if fid == 1:
12263 
        if ftype == TType.I64:
12264 
          self.orderId = iprot.readI64();
12265 
        else:
12266 
          iprot.skip(ftype)
12267 
      elif fid == 2:
12268 
        if ftype == TType.BOOL:
12269 
          self.isAuthorized = iprot.readBool();
12270 
        else:
12271 
          iprot.skip(ftype)
12272 
      else:
12273 
        iprot.skip(ftype)
12274 
      iprot.readFieldEnd()
12275 
    iprot.readStructEnd()
12276 
 
12277 
  def write(self, oprot):
12278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12280 
      return
12281 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12282 
    if self.orderId is not None:
12283 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12284 
      oprot.writeI64(self.orderId)
12285 
      oprot.writeFieldEnd()
12286 
    if self.isAuthorized is not None:
12287 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12288 
      oprot.writeBool(self.isAuthorized)
12289 
      oprot.writeFieldEnd()
12290 
    oprot.writeFieldStop()
12291 
    oprot.writeStructEnd()
12292 
 
12293 
  def validate(self):
12294 
    return
12295 
 
12296 
 
12297 
  def __repr__(self):
12298 
    L = ['%s=%r' % (key, value)
12299 
      for key, value in self.__dict__.iteritems()]
12300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12301 
 
12302 
  def __eq__(self, other):
12303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12304 
 
12305 
  def __ne__(self, other):
12306 
    return not (self == other)
12307 
 
12308 
class markOrderDoaRequestAuthorized_result:
12309 
  """
12310 
  Attributes:
12311 
   - success
12312 
   - ex
12313 
  """
12314 
 
12315 
  thrift_spec = (
12316 
    (0, TType.BOOL, 'success', None, None, ), # 0
12317 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12318 
  )
12319 
 
12320 
  def __init__(self, success=None, ex=None,):
12321 
    self.success = success
12322 
    self.ex = ex
12323 
 
12324 
  def read(self, iprot):
12325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12327 
      return
12328 
    iprot.readStructBegin()
12329 
    while True:
12330 
      (fname, ftype, fid) = iprot.readFieldBegin()
12331 
      if ftype == TType.STOP:
12332 
        break
12333 
      if fid == 0:
12334 
        if ftype == TType.BOOL:
12335 
          self.success = iprot.readBool();
12336 
        else:
12337 
          iprot.skip(ftype)
12338 
      elif fid == 1:
12339 
        if ftype == TType.STRUCT:
12340 
          self.ex = TransactionServiceException()
12341 
          self.ex.read(iprot)
12342 
        else:
12343 
          iprot.skip(ftype)
12344 
      else:
12345 
        iprot.skip(ftype)
12346 
      iprot.readFieldEnd()
12347 
    iprot.readStructEnd()
12348 
 
12349 
  def write(self, oprot):
12350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12352 
      return
12353 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12354 
    if self.success is not None:
12355 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12356 
      oprot.writeBool(self.success)
12357 
      oprot.writeFieldEnd()
12358 
    if self.ex is not None:
12359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12360 
      self.ex.write(oprot)
12361 
      oprot.writeFieldEnd()
12362 
    oprot.writeFieldStop()
12363 
    oprot.writeStructEnd()
12364 
 
12365 
  def validate(self):
12366 
    return
12367 
 
12368 
 
12369 
  def __repr__(self):
12370 
    L = ['%s=%r' % (key, value)
12371 
      for key, value in self.__dict__.iteritems()]
12372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12373 
 
12374 
  def __eq__(self, other):
12375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12376 
 
12377 
  def __ne__(self, other):
12378 
    return not (self == other)
12379 
 
4488 rajveer 12380 
class markOrderReturnRequestReceived_args:
12381 
  """
12382 
  Attributes:
12383 
   - orderId
12384 
  """
12385 
 
12386 
  thrift_spec = (
12387 
    None, # 0
12388 
    (1, TType.I64, 'orderId', None, None, ), # 1
12389 
  )
12390 
 
12391 
  def __init__(self, orderId=None,):
12392 
    self.orderId = orderId
12393 
 
12394 
  def read(self, iprot):
12395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12397 
      return
12398 
    iprot.readStructBegin()
12399 
    while True:
12400 
      (fname, ftype, fid) = iprot.readFieldBegin()
12401 
      if ftype == TType.STOP:
12402 
        break
12403 
      if fid == 1:
12404 
        if ftype == TType.I64:
12405 
          self.orderId = iprot.readI64();
12406 
        else:
12407 
          iprot.skip(ftype)
12408 
      else:
12409 
        iprot.skip(ftype)
12410 
      iprot.readFieldEnd()
12411 
    iprot.readStructEnd()
12412 
 
12413 
  def write(self, oprot):
12414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12416 
      return
12417 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12418 
    if self.orderId is not None:
12419 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12420 
      oprot.writeI64(self.orderId)
12421 
      oprot.writeFieldEnd()
12422 
    oprot.writeFieldStop()
12423 
    oprot.writeStructEnd()
12424 
 
12425 
  def validate(self):
12426 
    return
12427 
 
12428 
 
12429 
  def __repr__(self):
12430 
    L = ['%s=%r' % (key, value)
12431 
      for key, value in self.__dict__.iteritems()]
12432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12433 
 
12434 
  def __eq__(self, other):
12435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12436 
 
12437 
  def __ne__(self, other):
12438 
    return not (self == other)
12439 
 
12440 
class markOrderReturnRequestReceived_result:
12441 
  """
12442 
  Attributes:
12443 
   - success
12444 
   - ex
12445 
  """
12446 
 
12447 
  thrift_spec = (
12448 
    (0, TType.BOOL, 'success', None, None, ), # 0
12449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12450 
  )
12451 
 
12452 
  def __init__(self, success=None, ex=None,):
12453 
    self.success = success
12454 
    self.ex = ex
12455 
 
12456 
  def read(self, iprot):
12457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12459 
      return
12460 
    iprot.readStructBegin()
12461 
    while True:
12462 
      (fname, ftype, fid) = iprot.readFieldBegin()
12463 
      if ftype == TType.STOP:
12464 
        break
12465 
      if fid == 0:
12466 
        if ftype == TType.BOOL:
12467 
          self.success = iprot.readBool();
12468 
        else:
12469 
          iprot.skip(ftype)
12470 
      elif fid == 1:
12471 
        if ftype == TType.STRUCT:
12472 
          self.ex = TransactionServiceException()
12473 
          self.ex.read(iprot)
12474 
        else:
12475 
          iprot.skip(ftype)
12476 
      else:
12477 
        iprot.skip(ftype)
12478 
      iprot.readFieldEnd()
12479 
    iprot.readStructEnd()
12480 
 
12481 
  def write(self, oprot):
12482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12484 
      return
12485 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12486 
    if self.success is not None:
12487 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12488 
      oprot.writeBool(self.success)
12489 
      oprot.writeFieldEnd()
12490 
    if self.ex is not None:
12491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12492 
      self.ex.write(oprot)
12493 
      oprot.writeFieldEnd()
12494 
    oprot.writeFieldStop()
12495 
    oprot.writeStructEnd()
12496 
 
12497 
  def validate(self):
12498 
    return
12499 
 
12500 
 
12501 
  def __repr__(self):
12502 
    L = ['%s=%r' % (key, value)
12503 
      for key, value in self.__dict__.iteritems()]
12504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12505 
 
12506 
  def __eq__(self, other):
12507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12508 
 
12509 
  def __ne__(self, other):
12510 
    return not (self == other)
12511 
 
12512 
class markOrderReturnRequestAuthorized_args:
12513 
  """
12514 
  Attributes:
12515 
   - orderId
12516 
   - isAuthorized
12517 
  """
12518 
 
12519 
  thrift_spec = (
12520 
    None, # 0
12521 
    (1, TType.I64, 'orderId', None, None, ), # 1
12522 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12523 
  )
12524 
 
12525 
  def __init__(self, orderId=None, isAuthorized=None,):
12526 
    self.orderId = orderId
12527 
    self.isAuthorized = isAuthorized
12528 
 
12529 
  def read(self, iprot):
12530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12532 
      return
12533 
    iprot.readStructBegin()
12534 
    while True:
12535 
      (fname, ftype, fid) = iprot.readFieldBegin()
12536 
      if ftype == TType.STOP:
12537 
        break
12538 
      if fid == 1:
12539 
        if ftype == TType.I64:
12540 
          self.orderId = iprot.readI64();
12541 
        else:
12542 
          iprot.skip(ftype)
12543 
      elif fid == 2:
12544 
        if ftype == TType.BOOL:
12545 
          self.isAuthorized = iprot.readBool();
12546 
        else:
12547 
          iprot.skip(ftype)
12548 
      else:
12549 
        iprot.skip(ftype)
12550 
      iprot.readFieldEnd()
12551 
    iprot.readStructEnd()
12552 
 
12553 
  def write(self, oprot):
12554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12556 
      return
12557 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12558 
    if self.orderId is not None:
12559 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12560 
      oprot.writeI64(self.orderId)
12561 
      oprot.writeFieldEnd()
12562 
    if self.isAuthorized is not None:
12563 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12564 
      oprot.writeBool(self.isAuthorized)
12565 
      oprot.writeFieldEnd()
12566 
    oprot.writeFieldStop()
12567 
    oprot.writeStructEnd()
12568 
 
12569 
  def validate(self):
12570 
    return
12571 
 
12572 
 
12573 
  def __repr__(self):
12574 
    L = ['%s=%r' % (key, value)
12575 
      for key, value in self.__dict__.iteritems()]
12576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12577 
 
12578 
  def __eq__(self, other):
12579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12580 
 
12581 
  def __ne__(self, other):
12582 
    return not (self == other)
12583 
 
12584 
class markOrderReturnRequestAuthorized_result:
12585 
  """
12586 
  Attributes:
12587 
   - success
12588 
   - ex
12589 
  """
12590 
 
12591 
  thrift_spec = (
12592 
    (0, TType.BOOL, 'success', None, None, ), # 0
12593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12594 
  )
12595 
 
12596 
  def __init__(self, success=None, ex=None,):
12597 
    self.success = success
12598 
    self.ex = ex
12599 
 
12600 
  def read(self, iprot):
12601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12603 
      return
12604 
    iprot.readStructBegin()
12605 
    while True:
12606 
      (fname, ftype, fid) = iprot.readFieldBegin()
12607 
      if ftype == TType.STOP:
12608 
        break
12609 
      if fid == 0:
12610 
        if ftype == TType.BOOL:
12611 
          self.success = iprot.readBool();
12612 
        else:
12613 
          iprot.skip(ftype)
12614 
      elif fid == 1:
12615 
        if ftype == TType.STRUCT:
12616 
          self.ex = TransactionServiceException()
12617 
          self.ex.read(iprot)
12618 
        else:
12619 
          iprot.skip(ftype)
12620 
      else:
12621 
        iprot.skip(ftype)
12622 
      iprot.readFieldEnd()
12623 
    iprot.readStructEnd()
12624 
 
12625 
  def write(self, oprot):
12626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12628 
      return
12629 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12630 
    if self.success is not None:
12631 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12632 
      oprot.writeBool(self.success)
12633 
      oprot.writeFieldEnd()
12634 
    if self.ex is not None:
12635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12636 
      self.ex.write(oprot)
12637 
      oprot.writeFieldEnd()
12638 
    oprot.writeFieldStop()
12639 
    oprot.writeStructEnd()
12640 
 
12641 
  def validate(self):
12642 
    return
12643 
 
12644 
 
12645 
  def __repr__(self):
12646 
    L = ['%s=%r' % (key, value)
12647 
      for key, value in self.__dict__.iteritems()]
12648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12649 
 
12650 
  def __eq__(self, other):
12651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12652 
 
12653 
  def __ne__(self, other):
12654 
    return not (self == other)
12655 
 
2536 chandransh 12656 
class requestPickupNumber_args:
12657 
  """
12658 
  Attributes:
12659 
   - orderId
4579 rajveer 12660 
   - providerId
2536 chandransh 12661 
  """
12662 
 
12663 
  thrift_spec = (
12664 
    None, # 0
12665 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12666 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12667 
  )
12668 
 
4579 rajveer 12669 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12670 
    self.orderId = orderId
4579 rajveer 12671 
    self.providerId = providerId
2536 chandransh 12672 
 
12673 
  def read(self, iprot):
12674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12676 
      return
12677 
    iprot.readStructBegin()
12678 
    while True:
12679 
      (fname, ftype, fid) = iprot.readFieldBegin()
12680 
      if ftype == TType.STOP:
12681 
        break
12682 
      if fid == 1:
12683 
        if ftype == TType.I64:
12684 
          self.orderId = iprot.readI64();
12685 
        else:
12686 
          iprot.skip(ftype)
4579 rajveer 12687 
      elif fid == 2:
12688 
        if ftype == TType.I64:
12689 
          self.providerId = iprot.readI64();
12690 
        else:
12691 
          iprot.skip(ftype)
2536 chandransh 12692 
      else:
12693 
        iprot.skip(ftype)
12694 
      iprot.readFieldEnd()
12695 
    iprot.readStructEnd()
12696 
 
12697 
  def write(self, oprot):
12698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12700 
      return
12701 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12702 
    if self.orderId is not None:
2536 chandransh 12703 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12704 
      oprot.writeI64(self.orderId)
12705 
      oprot.writeFieldEnd()
4579 rajveer 12706 
    if self.providerId is not None:
12707 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12708 
      oprot.writeI64(self.providerId)
12709 
      oprot.writeFieldEnd()
2536 chandransh 12710 
    oprot.writeFieldStop()
12711 
    oprot.writeStructEnd()
12712 
 
3431 rajveer 12713 
  def validate(self):
12714 
    return
12715 
 
12716 
 
2536 chandransh 12717 
  def __repr__(self):
12718 
    L = ['%s=%r' % (key, value)
12719 
      for key, value in self.__dict__.iteritems()]
12720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12721 
 
12722 
  def __eq__(self, other):
12723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12724 
 
12725 
  def __ne__(self, other):
12726 
    return not (self == other)
12727 
 
12728 
class requestPickupNumber_result:
12729 
  """
12730 
  Attributes:
12731 
   - success
12732 
   - ex
12733 
  """
12734 
 
12735 
  thrift_spec = (
12736 
    (0, TType.BOOL, 'success', None, None, ), # 0
12737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12738 
  )
12739 
 
12740 
  def __init__(self, success=None, ex=None,):
12741 
    self.success = success
12742 
    self.ex = ex
12743 
 
12744 
  def read(self, iprot):
12745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12747 
      return
12748 
    iprot.readStructBegin()
12749 
    while True:
12750 
      (fname, ftype, fid) = iprot.readFieldBegin()
12751 
      if ftype == TType.STOP:
12752 
        break
12753 
      if fid == 0:
12754 
        if ftype == TType.BOOL:
12755 
          self.success = iprot.readBool();
12756 
        else:
12757 
          iprot.skip(ftype)
12758 
      elif fid == 1:
12759 
        if ftype == TType.STRUCT:
12760 
          self.ex = TransactionServiceException()
12761 
          self.ex.read(iprot)
12762 
        else:
12763 
          iprot.skip(ftype)
12764 
      else:
12765 
        iprot.skip(ftype)
12766 
      iprot.readFieldEnd()
12767 
    iprot.readStructEnd()
12768 
 
12769 
  def write(self, oprot):
12770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12772 
      return
12773 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12774 
    if self.success is not None:
2536 chandransh 12775 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12776 
      oprot.writeBool(self.success)
12777 
      oprot.writeFieldEnd()
3431 rajveer 12778 
    if self.ex is not None:
2536 chandransh 12779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12780 
      self.ex.write(oprot)
12781 
      oprot.writeFieldEnd()
12782 
    oprot.writeFieldStop()
12783 
    oprot.writeStructEnd()
12784 
 
3431 rajveer 12785 
  def validate(self):
12786 
    return
12787 
 
12788 
 
2536 chandransh 12789 
  def __repr__(self):
12790 
    L = ['%s=%r' % (key, value)
12791 
      for key, value in self.__dict__.iteritems()]
12792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12793 
 
12794 
  def __eq__(self, other):
12795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12796 
 
12797 
  def __ne__(self, other):
12798 
    return not (self == other)
12799 
 
12800 
class authorizePickup_args:
12801 
  """
12802 
  Attributes:
12803 
   - orderId
12804 
   - pickupNumber
4602 rajveer 12805 
   - providerId
2536 chandransh 12806 
  """
12807 
 
12808 
  thrift_spec = (
12809 
    None, # 0
12810 
    (1, TType.I64, 'orderId', None, None, ), # 1
12811 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12812 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12813 
  )
12814 
 
4602 rajveer 12815 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12816 
    self.orderId = orderId
12817 
    self.pickupNumber = pickupNumber
4602 rajveer 12818 
    self.providerId = providerId
2536 chandransh 12819 
 
12820 
  def read(self, iprot):
12821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12823 
      return
12824 
    iprot.readStructBegin()
12825 
    while True:
12826 
      (fname, ftype, fid) = iprot.readFieldBegin()
12827 
      if ftype == TType.STOP:
12828 
        break
12829 
      if fid == 1:
12830 
        if ftype == TType.I64:
12831 
          self.orderId = iprot.readI64();
12832 
        else:
12833 
          iprot.skip(ftype)
12834 
      elif fid == 2:
12835 
        if ftype == TType.STRING:
12836 
          self.pickupNumber = iprot.readString();
12837 
        else:
12838 
          iprot.skip(ftype)
4602 rajveer 12839 
      elif fid == 3:
12840 
        if ftype == TType.I64:
12841 
          self.providerId = iprot.readI64();
12842 
        else:
12843 
          iprot.skip(ftype)
2536 chandransh 12844 
      else:
12845 
        iprot.skip(ftype)
12846 
      iprot.readFieldEnd()
12847 
    iprot.readStructEnd()
12848 
 
12849 
  def write(self, oprot):
12850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12852 
      return
12853 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12854 
    if self.orderId is not None:
2536 chandransh 12855 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12856 
      oprot.writeI64(self.orderId)
12857 
      oprot.writeFieldEnd()
3431 rajveer 12858 
    if self.pickupNumber is not None:
2536 chandransh 12859 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12860 
      oprot.writeString(self.pickupNumber)
12861 
      oprot.writeFieldEnd()
4602 rajveer 12862 
    if self.providerId is not None:
12863 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12864 
      oprot.writeI64(self.providerId)
12865 
      oprot.writeFieldEnd()
2536 chandransh 12866 
    oprot.writeFieldStop()
12867 
    oprot.writeStructEnd()
12868 
 
3431 rajveer 12869 
  def validate(self):
12870 
    return
12871 
 
12872 
 
2536 chandransh 12873 
  def __repr__(self):
12874 
    L = ['%s=%r' % (key, value)
12875 
      for key, value in self.__dict__.iteritems()]
12876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12877 
 
12878 
  def __eq__(self, other):
12879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12880 
 
12881 
  def __ne__(self, other):
12882 
    return not (self == other)
12883 
 
12884 
class authorizePickup_result:
12885 
  """
12886 
  Attributes:
12887 
   - success
12888 
   - ex
12889 
  """
12890 
 
12891 
  thrift_spec = (
12892 
    (0, TType.BOOL, 'success', None, None, ), # 0
12893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12894 
  )
12895 
 
12896 
  def __init__(self, success=None, ex=None,):
12897 
    self.success = success
12898 
    self.ex = ex
12899 
 
12900 
  def read(self, iprot):
12901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12903 
      return
12904 
    iprot.readStructBegin()
12905 
    while True:
12906 
      (fname, ftype, fid) = iprot.readFieldBegin()
12907 
      if ftype == TType.STOP:
12908 
        break
12909 
      if fid == 0:
12910 
        if ftype == TType.BOOL:
12911 
          self.success = iprot.readBool();
12912 
        else:
12913 
          iprot.skip(ftype)
12914 
      elif fid == 1:
12915 
        if ftype == TType.STRUCT:
12916 
          self.ex = TransactionServiceException()
12917 
          self.ex.read(iprot)
12918 
        else:
12919 
          iprot.skip(ftype)
12920 
      else:
12921 
        iprot.skip(ftype)
12922 
      iprot.readFieldEnd()
12923 
    iprot.readStructEnd()
12924 
 
12925 
  def write(self, oprot):
12926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12928 
      return
12929 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12930 
    if self.success is not None:
2536 chandransh 12931 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12932 
      oprot.writeBool(self.success)
12933 
      oprot.writeFieldEnd()
3431 rajveer 12934 
    if self.ex is not None:
2536 chandransh 12935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12936 
      self.ex.write(oprot)
12937 
      oprot.writeFieldEnd()
12938 
    oprot.writeFieldStop()
12939 
    oprot.writeStructEnd()
12940 
 
3431 rajveer 12941 
  def validate(self):
12942 
    return
12943 
 
12944 
 
2536 chandransh 12945 
  def __repr__(self):
12946 
    L = ['%s=%r' % (key, value)
12947 
      for key, value in self.__dict__.iteritems()]
12948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12949 
 
12950 
  def __eq__(self, other):
12951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12952 
 
12953 
  def __ne__(self, other):
12954 
    return not (self == other)
12955 
 
2764 chandransh 12956 
class markDoasAsPickedUp_args:
12957 
  """
12958 
  Attributes:
12959 
   - providerId
12960 
   - pickupDetails
12961 
  """
12962 
 
12963 
  thrift_spec = (
12964 
    None, # 0
12965 
    (1, TType.I64, 'providerId', None, None, ), # 1
12966 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12967 
  )
12968 
 
12969 
  def __init__(self, providerId=None, pickupDetails=None,):
12970 
    self.providerId = providerId
12971 
    self.pickupDetails = pickupDetails
12972 
 
12973 
  def read(self, iprot):
12974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12976 
      return
12977 
    iprot.readStructBegin()
12978 
    while True:
12979 
      (fname, ftype, fid) = iprot.readFieldBegin()
12980 
      if ftype == TType.STOP:
12981 
        break
12982 
      if fid == 1:
12983 
        if ftype == TType.I64:
12984 
          self.providerId = iprot.readI64();
12985 
        else:
12986 
          iprot.skip(ftype)
12987 
      elif fid == 2:
12988 
        if ftype == TType.MAP:
12989 
          self.pickupDetails = {}
4581 phani.kuma 12990 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12991 
          for _i201 in xrange(_size197):
12992 
            _key202 = iprot.readString();
12993 
            _val203 = iprot.readString();
12994 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12995 
          iprot.readMapEnd()
12996 
        else:
12997 
          iprot.skip(ftype)
12998 
      else:
12999 
        iprot.skip(ftype)
13000 
      iprot.readFieldEnd()
13001 
    iprot.readStructEnd()
13002 
 
13003 
  def write(self, oprot):
13004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13006 
      return
13007 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13008 
    if self.providerId is not None:
2764 chandransh 13009 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13010 
      oprot.writeI64(self.providerId)
13011 
      oprot.writeFieldEnd()
3431 rajveer 13012 
    if self.pickupDetails is not None:
2764 chandransh 13013 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13014 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 13015 
      for kiter204,viter205 in self.pickupDetails.items():
13016 
        oprot.writeString(kiter204)
13017 
        oprot.writeString(viter205)
2764 chandransh 13018 
      oprot.writeMapEnd()
13019 
      oprot.writeFieldEnd()
13020 
    oprot.writeFieldStop()
13021 
    oprot.writeStructEnd()
13022 
 
3431 rajveer 13023 
  def validate(self):
13024 
    return
13025 
 
13026 
 
2764 chandransh 13027 
  def __repr__(self):
13028 
    L = ['%s=%r' % (key, value)
13029 
      for key, value in self.__dict__.iteritems()]
13030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13031 
 
13032 
  def __eq__(self, other):
13033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13034 
 
13035 
  def __ne__(self, other):
13036 
    return not (self == other)
13037 
 
13038 
class markDoasAsPickedUp_result:
13039 
  """
13040 
  Attributes:
13041 
   - success
13042 
  """
13043 
 
13044 
  thrift_spec = (
13045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13046 
  )
13047 
 
13048 
  def __init__(self, success=None,):
13049 
    self.success = success
13050 
 
13051 
  def read(self, iprot):
13052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13054 
      return
13055 
    iprot.readStructBegin()
13056 
    while True:
13057 
      (fname, ftype, fid) = iprot.readFieldBegin()
13058 
      if ftype == TType.STOP:
13059 
        break
13060 
      if fid == 0:
13061 
        if ftype == TType.LIST:
13062 
          self.success = []
4581 phani.kuma 13063 
          (_etype209, _size206) = iprot.readListBegin()
13064 
          for _i210 in xrange(_size206):
13065 
            _elem211 = Order()
13066 
            _elem211.read(iprot)
13067 
            self.success.append(_elem211)
2764 chandransh 13068 
          iprot.readListEnd()
13069 
        else:
13070 
          iprot.skip(ftype)
13071 
      else:
13072 
        iprot.skip(ftype)
13073 
      iprot.readFieldEnd()
13074 
    iprot.readStructEnd()
13075 
 
13076 
  def write(self, oprot):
13077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13079 
      return
13080 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13081 
    if self.success is not None:
2764 chandransh 13082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13084 
      for iter212 in self.success:
13085 
        iter212.write(oprot)
2764 chandransh 13086 
      oprot.writeListEnd()
13087 
      oprot.writeFieldEnd()
13088 
    oprot.writeFieldStop()
13089 
    oprot.writeStructEnd()
13090 
 
3431 rajveer 13091 
  def validate(self):
13092 
    return
13093 
 
13094 
 
2764 chandransh 13095 
  def __repr__(self):
13096 
    L = ['%s=%r' % (key, value)
13097 
      for key, value in self.__dict__.iteritems()]
13098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13099 
 
13100 
  def __eq__(self, other):
13101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13102 
 
13103 
  def __ne__(self, other):
13104 
    return not (self == other)
13105 
 
4741 phani.kuma 13106 
class markReturnOrdersAsPickedUp_args:
13107 
  """
13108 
  Attributes:
13109 
   - providerId
13110 
   - pickupDetails
13111 
  """
13112 
 
13113 
  thrift_spec = (
13114 
    None, # 0
13115 
    (1, TType.I64, 'providerId', None, None, ), # 1
13116 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13117 
  )
13118 
 
13119 
  def __init__(self, providerId=None, pickupDetails=None,):
13120 
    self.providerId = providerId
13121 
    self.pickupDetails = pickupDetails
13122 
 
13123 
  def read(self, iprot):
13124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13126 
      return
13127 
    iprot.readStructBegin()
13128 
    while True:
13129 
      (fname, ftype, fid) = iprot.readFieldBegin()
13130 
      if ftype == TType.STOP:
13131 
        break
13132 
      if fid == 1:
13133 
        if ftype == TType.I64:
13134 
          self.providerId = iprot.readI64();
13135 
        else:
13136 
          iprot.skip(ftype)
13137 
      elif fid == 2:
13138 
        if ftype == TType.MAP:
13139 
          self.pickupDetails = {}
13140 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13141 
          for _i217 in xrange(_size213):
13142 
            _key218 = iprot.readString();
13143 
            _val219 = iprot.readString();
13144 
            self.pickupDetails[_key218] = _val219
13145 
          iprot.readMapEnd()
13146 
        else:
13147 
          iprot.skip(ftype)
13148 
      else:
13149 
        iprot.skip(ftype)
13150 
      iprot.readFieldEnd()
13151 
    iprot.readStructEnd()
13152 
 
13153 
  def write(self, oprot):
13154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13156 
      return
13157 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13158 
    if self.providerId is not None:
13159 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13160 
      oprot.writeI64(self.providerId)
13161 
      oprot.writeFieldEnd()
13162 
    if self.pickupDetails is not None:
13163 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13164 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
13165 
      for kiter220,viter221 in self.pickupDetails.items():
13166 
        oprot.writeString(kiter220)
13167 
        oprot.writeString(viter221)
13168 
      oprot.writeMapEnd()
13169 
      oprot.writeFieldEnd()
13170 
    oprot.writeFieldStop()
13171 
    oprot.writeStructEnd()
13172 
 
13173 
  def validate(self):
13174 
    return
13175 
 
13176 
 
13177 
  def __repr__(self):
13178 
    L = ['%s=%r' % (key, value)
13179 
      for key, value in self.__dict__.iteritems()]
13180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13181 
 
13182 
  def __eq__(self, other):
13183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13184 
 
13185 
  def __ne__(self, other):
13186 
    return not (self == other)
13187 
 
13188 
class markReturnOrdersAsPickedUp_result:
13189 
  """
13190 
  Attributes:
13191 
   - success
13192 
  """
13193 
 
13194 
  thrift_spec = (
13195 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13196 
  )
13197 
 
13198 
  def __init__(self, success=None,):
13199 
    self.success = success
13200 
 
13201 
  def read(self, iprot):
13202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13204 
      return
13205 
    iprot.readStructBegin()
13206 
    while True:
13207 
      (fname, ftype, fid) = iprot.readFieldBegin()
13208 
      if ftype == TType.STOP:
13209 
        break
13210 
      if fid == 0:
13211 
        if ftype == TType.LIST:
13212 
          self.success = []
13213 
          (_etype225, _size222) = iprot.readListBegin()
13214 
          for _i226 in xrange(_size222):
13215 
            _elem227 = Order()
13216 
            _elem227.read(iprot)
13217 
            self.success.append(_elem227)
13218 
          iprot.readListEnd()
13219 
        else:
13220 
          iprot.skip(ftype)
13221 
      else:
13222 
        iprot.skip(ftype)
13223 
      iprot.readFieldEnd()
13224 
    iprot.readStructEnd()
13225 
 
13226 
  def write(self, oprot):
13227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13229 
      return
13230 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13231 
    if self.success is not None:
13232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13234 
      for iter228 in self.success:
13235 
        iter228.write(oprot)
13236 
      oprot.writeListEnd()
13237 
      oprot.writeFieldEnd()
13238 
    oprot.writeFieldStop()
13239 
    oprot.writeStructEnd()
13240 
 
13241 
  def validate(self):
13242 
    return
13243 
 
13244 
 
13245 
  def __repr__(self):
13246 
    L = ['%s=%r' % (key, value)
13247 
      for key, value in self.__dict__.iteritems()]
13248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13249 
 
13250 
  def __eq__(self, other):
13251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13252 
 
13253 
  def __ne__(self, other):
13254 
    return not (self == other)
13255 
 
2616 chandransh 13256 
class receiveReturn_args:
2591 chandransh 13257 
  """
13258 
  Attributes:
13259 
   - orderId
4479 rajveer 13260 
   - receiveCondition
2591 chandransh 13261 
  """
2536 chandransh 13262 
 
2591 chandransh 13263 
  thrift_spec = (
13264 
    None, # 0
13265 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13266 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13267 
  )
13268 
 
4479 rajveer 13269 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13270 
    self.orderId = orderId
4479 rajveer 13271 
    self.receiveCondition = receiveCondition
2591 chandransh 13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      if fid == 1:
13283 
        if ftype == TType.I64:
13284 
          self.orderId = iprot.readI64();
13285 
        else:
13286 
          iprot.skip(ftype)
4479 rajveer 13287 
      elif fid == 2:
13288 
        if ftype == TType.I64:
13289 
          self.receiveCondition = iprot.readI64();
13290 
        else:
13291 
          iprot.skip(ftype)
2591 chandransh 13292 
      else:
13293 
        iprot.skip(ftype)
13294 
      iprot.readFieldEnd()
13295 
    iprot.readStructEnd()
13296 
 
13297 
  def write(self, oprot):
13298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13300 
      return
2616 chandransh 13301 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13302 
    if self.orderId is not None:
2591 chandransh 13303 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13304 
      oprot.writeI64(self.orderId)
13305 
      oprot.writeFieldEnd()
4479 rajveer 13306 
    if self.receiveCondition is not None:
13307 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13308 
      oprot.writeI64(self.receiveCondition)
13309 
      oprot.writeFieldEnd()
2591 chandransh 13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
3431 rajveer 13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
2591 chandransh 13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
13327 
 
2616 chandransh 13328 
class receiveReturn_result:
2591 chandransh 13329 
  """
13330 
  Attributes:
13331 
   - success
13332 
   - ex
13333 
  """
13334 
 
13335 
  thrift_spec = (
13336 
    (0, TType.BOOL, 'success', None, None, ), # 0
13337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13338 
  )
13339 
 
13340 
  def __init__(self, success=None, ex=None,):
13341 
    self.success = success
13342 
    self.ex = ex
13343 
 
13344 
  def read(self, iprot):
13345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13347 
      return
13348 
    iprot.readStructBegin()
13349 
    while True:
13350 
      (fname, ftype, fid) = iprot.readFieldBegin()
13351 
      if ftype == TType.STOP:
13352 
        break
13353 
      if fid == 0:
13354 
        if ftype == TType.BOOL:
13355 
          self.success = iprot.readBool();
13356 
        else:
13357 
          iprot.skip(ftype)
13358 
      elif fid == 1:
13359 
        if ftype == TType.STRUCT:
13360 
          self.ex = TransactionServiceException()
13361 
          self.ex.read(iprot)
13362 
        else:
13363 
          iprot.skip(ftype)
13364 
      else:
13365 
        iprot.skip(ftype)
13366 
      iprot.readFieldEnd()
13367 
    iprot.readStructEnd()
13368 
 
13369 
  def write(self, oprot):
13370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13372 
      return
2616 chandransh 13373 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13374 
    if self.success is not None:
2591 chandransh 13375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13376 
      oprot.writeBool(self.success)
13377 
      oprot.writeFieldEnd()
3431 rajveer 13378 
    if self.ex is not None:
2591 chandransh 13379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13380 
      self.ex.write(oprot)
13381 
      oprot.writeFieldEnd()
13382 
    oprot.writeFieldStop()
13383 
    oprot.writeStructEnd()
13384 
 
3431 rajveer 13385 
  def validate(self):
13386 
    return
13387 
 
13388 
 
2591 chandransh 13389 
  def __repr__(self):
13390 
    L = ['%s=%r' % (key, value)
13391 
      for key, value in self.__dict__.iteritems()]
13392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13393 
 
13394 
  def __eq__(self, other):
13395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13396 
 
13397 
  def __ne__(self, other):
13398 
    return not (self == other)
13399 
 
13400 
class validateDoa_args:
13401 
  """
13402 
  Attributes:
13403 
   - orderId
13404 
   - isValid
13405 
  """
13406 
 
13407 
  thrift_spec = (
13408 
    None, # 0
13409 
    (1, TType.I64, 'orderId', None, None, ), # 1
13410 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13411 
  )
13412 
 
13413 
  def __init__(self, orderId=None, isValid=None,):
13414 
    self.orderId = orderId
13415 
    self.isValid = isValid
13416 
 
13417 
  def read(self, iprot):
13418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13420 
      return
13421 
    iprot.readStructBegin()
13422 
    while True:
13423 
      (fname, ftype, fid) = iprot.readFieldBegin()
13424 
      if ftype == TType.STOP:
13425 
        break
13426 
      if fid == 1:
13427 
        if ftype == TType.I64:
13428 
          self.orderId = iprot.readI64();
13429 
        else:
13430 
          iprot.skip(ftype)
13431 
      elif fid == 2:
13432 
        if ftype == TType.BOOL:
13433 
          self.isValid = iprot.readBool();
13434 
        else:
13435 
          iprot.skip(ftype)
13436 
      else:
13437 
        iprot.skip(ftype)
13438 
      iprot.readFieldEnd()
13439 
    iprot.readStructEnd()
13440 
 
13441 
  def write(self, oprot):
13442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13444 
      return
13445 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13446 
    if self.orderId is not None:
2591 chandransh 13447 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13448 
      oprot.writeI64(self.orderId)
13449 
      oprot.writeFieldEnd()
3431 rajveer 13450 
    if self.isValid is not None:
2591 chandransh 13451 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13452 
      oprot.writeBool(self.isValid)
13453 
      oprot.writeFieldEnd()
13454 
    oprot.writeFieldStop()
13455 
    oprot.writeStructEnd()
13456 
 
3431 rajveer 13457 
  def validate(self):
13458 
    return
13459 
 
13460 
 
2591 chandransh 13461 
  def __repr__(self):
13462 
    L = ['%s=%r' % (key, value)
13463 
      for key, value in self.__dict__.iteritems()]
13464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13465 
 
13466 
  def __eq__(self, other):
13467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13468 
 
13469 
  def __ne__(self, other):
13470 
    return not (self == other)
13471 
 
13472 
class validateDoa_result:
13473 
  """
13474 
  Attributes:
13475 
   - success
13476 
   - ex
13477 
  """
13478 
 
13479 
  thrift_spec = (
13480 
    (0, TType.BOOL, 'success', None, None, ), # 0
13481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13482 
  )
13483 
 
13484 
  def __init__(self, success=None, ex=None,):
13485 
    self.success = success
13486 
    self.ex = ex
13487 
 
13488 
  def read(self, iprot):
13489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13491 
      return
13492 
    iprot.readStructBegin()
13493 
    while True:
13494 
      (fname, ftype, fid) = iprot.readFieldBegin()
13495 
      if ftype == TType.STOP:
13496 
        break
13497 
      if fid == 0:
13498 
        if ftype == TType.BOOL:
13499 
          self.success = iprot.readBool();
13500 
        else:
13501 
          iprot.skip(ftype)
13502 
      elif fid == 1:
13503 
        if ftype == TType.STRUCT:
13504 
          self.ex = TransactionServiceException()
13505 
          self.ex.read(iprot)
13506 
        else:
13507 
          iprot.skip(ftype)
13508 
      else:
13509 
        iprot.skip(ftype)
13510 
      iprot.readFieldEnd()
13511 
    iprot.readStructEnd()
13512 
 
13513 
  def write(self, oprot):
13514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13516 
      return
13517 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13518 
    if self.success is not None:
2591 chandransh 13519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13520 
      oprot.writeBool(self.success)
13521 
      oprot.writeFieldEnd()
3431 rajveer 13522 
    if self.ex is not None:
2591 chandransh 13523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13524 
      self.ex.write(oprot)
13525 
      oprot.writeFieldEnd()
13526 
    oprot.writeFieldStop()
13527 
    oprot.writeStructEnd()
13528 
 
3431 rajveer 13529 
  def validate(self):
13530 
    return
13531 
 
13532 
 
2591 chandransh 13533 
  def __repr__(self):
13534 
    L = ['%s=%r' % (key, value)
13535 
      for key, value in self.__dict__.iteritems()]
13536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13537 
 
13538 
  def __eq__(self, other):
13539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13540 
 
13541 
  def __ne__(self, other):
13542 
    return not (self == other)
13543 
 
4495 rajveer 13544 
class validateReturnProduct_args:
13545 
  """
13546 
  Attributes:
13547 
   - orderId
13548 
   - isUsable
13549 
  """
13550 
 
13551 
  thrift_spec = (
13552 
    None, # 0
13553 
    (1, TType.I64, 'orderId', None, None, ), # 1
13554 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13555 
  )
13556 
 
13557 
  def __init__(self, orderId=None, isUsable=None,):
13558 
    self.orderId = orderId
13559 
    self.isUsable = isUsable
13560 
 
13561 
  def read(self, iprot):
13562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13564 
      return
13565 
    iprot.readStructBegin()
13566 
    while True:
13567 
      (fname, ftype, fid) = iprot.readFieldBegin()
13568 
      if ftype == TType.STOP:
13569 
        break
13570 
      if fid == 1:
13571 
        if ftype == TType.I64:
13572 
          self.orderId = iprot.readI64();
13573 
        else:
13574 
          iprot.skip(ftype)
13575 
      elif fid == 2:
13576 
        if ftype == TType.BOOL:
13577 
          self.isUsable = iprot.readBool();
13578 
        else:
13579 
          iprot.skip(ftype)
13580 
      else:
13581 
        iprot.skip(ftype)
13582 
      iprot.readFieldEnd()
13583 
    iprot.readStructEnd()
13584 
 
13585 
  def write(self, oprot):
13586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13588 
      return
13589 
    oprot.writeStructBegin('validateReturnProduct_args')
13590 
    if self.orderId is not None:
13591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13592 
      oprot.writeI64(self.orderId)
13593 
      oprot.writeFieldEnd()
13594 
    if self.isUsable is not None:
13595 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13596 
      oprot.writeBool(self.isUsable)
13597 
      oprot.writeFieldEnd()
13598 
    oprot.writeFieldStop()
13599 
    oprot.writeStructEnd()
13600 
 
13601 
  def validate(self):
13602 
    return
13603 
 
13604 
 
13605 
  def __repr__(self):
13606 
    L = ['%s=%r' % (key, value)
13607 
      for key, value in self.__dict__.iteritems()]
13608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13609 
 
13610 
  def __eq__(self, other):
13611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13612 
 
13613 
  def __ne__(self, other):
13614 
    return not (self == other)
13615 
 
13616 
class validateReturnProduct_result:
13617 
  """
13618 
  Attributes:
13619 
   - success
13620 
   - ex
13621 
  """
13622 
 
13623 
  thrift_spec = (
13624 
    (0, TType.BOOL, 'success', None, None, ), # 0
13625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13626 
  )
13627 
 
13628 
  def __init__(self, success=None, ex=None,):
13629 
    self.success = success
13630 
    self.ex = ex
13631 
 
13632 
  def read(self, iprot):
13633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13635 
      return
13636 
    iprot.readStructBegin()
13637 
    while True:
13638 
      (fname, ftype, fid) = iprot.readFieldBegin()
13639 
      if ftype == TType.STOP:
13640 
        break
13641 
      if fid == 0:
13642 
        if ftype == TType.BOOL:
13643 
          self.success = iprot.readBool();
13644 
        else:
13645 
          iprot.skip(ftype)
13646 
      elif fid == 1:
13647 
        if ftype == TType.STRUCT:
13648 
          self.ex = TransactionServiceException()
13649 
          self.ex.read(iprot)
13650 
        else:
13651 
          iprot.skip(ftype)
13652 
      else:
13653 
        iprot.skip(ftype)
13654 
      iprot.readFieldEnd()
13655 
    iprot.readStructEnd()
13656 
 
13657 
  def write(self, oprot):
13658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13660 
      return
13661 
    oprot.writeStructBegin('validateReturnProduct_result')
13662 
    if self.success is not None:
13663 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13664 
      oprot.writeBool(self.success)
13665 
      oprot.writeFieldEnd()
13666 
    if self.ex is not None:
13667 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13668 
      self.ex.write(oprot)
13669 
      oprot.writeFieldEnd()
13670 
    oprot.writeFieldStop()
13671 
    oprot.writeStructEnd()
13672 
 
13673 
  def validate(self):
13674 
    return
13675 
 
13676 
 
13677 
  def __repr__(self):
13678 
    L = ['%s=%r' % (key, value)
13679 
      for key, value in self.__dict__.iteritems()]
13680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13681 
 
13682 
  def __eq__(self, other):
13683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13684 
 
13685 
  def __ne__(self, other):
13686 
    return not (self == other)
13687 
 
2616 chandransh 13688 
class reshipOrder_args:
13689 
  """
13690 
  Attributes:
13691 
   - orderId
13692 
  """
2591 chandransh 13693 
 
2616 chandransh 13694 
  thrift_spec = (
13695 
    None, # 0
13696 
    (1, TType.I64, 'orderId', None, None, ), # 1
13697 
  )
13698 
 
13699 
  def __init__(self, orderId=None,):
13700 
    self.orderId = orderId
13701 
 
13702 
  def read(self, iprot):
13703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13705 
      return
13706 
    iprot.readStructBegin()
13707 
    while True:
13708 
      (fname, ftype, fid) = iprot.readFieldBegin()
13709 
      if ftype == TType.STOP:
13710 
        break
13711 
      if fid == 1:
13712 
        if ftype == TType.I64:
13713 
          self.orderId = iprot.readI64();
13714 
        else:
13715 
          iprot.skip(ftype)
13716 
      else:
13717 
        iprot.skip(ftype)
13718 
      iprot.readFieldEnd()
13719 
    iprot.readStructEnd()
13720 
 
13721 
  def write(self, oprot):
13722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13724 
      return
13725 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13726 
    if self.orderId is not None:
2616 chandransh 13727 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13728 
      oprot.writeI64(self.orderId)
13729 
      oprot.writeFieldEnd()
13730 
    oprot.writeFieldStop()
13731 
    oprot.writeStructEnd()
13732 
 
3431 rajveer 13733 
  def validate(self):
13734 
    return
13735 
 
13736 
 
2616 chandransh 13737 
  def __repr__(self):
13738 
    L = ['%s=%r' % (key, value)
13739 
      for key, value in self.__dict__.iteritems()]
13740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13741 
 
13742 
  def __eq__(self, other):
13743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13744 
 
13745 
  def __ne__(self, other):
13746 
    return not (self == other)
13747 
 
13748 
class reshipOrder_result:
13749 
  """
13750 
  Attributes:
13751 
   - success
13752 
   - ex
13753 
  """
13754 
 
13755 
  thrift_spec = (
13756 
    (0, TType.I64, 'success', None, None, ), # 0
13757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13758 
  )
13759 
 
13760 
  def __init__(self, success=None, ex=None,):
13761 
    self.success = success
13762 
    self.ex = ex
13763 
 
13764 
  def read(self, iprot):
13765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13767 
      return
13768 
    iprot.readStructBegin()
13769 
    while True:
13770 
      (fname, ftype, fid) = iprot.readFieldBegin()
13771 
      if ftype == TType.STOP:
13772 
        break
13773 
      if fid == 0:
13774 
        if ftype == TType.I64:
13775 
          self.success = iprot.readI64();
13776 
        else:
13777 
          iprot.skip(ftype)
13778 
      elif fid == 1:
13779 
        if ftype == TType.STRUCT:
13780 
          self.ex = TransactionServiceException()
13781 
          self.ex.read(iprot)
13782 
        else:
13783 
          iprot.skip(ftype)
13784 
      else:
13785 
        iprot.skip(ftype)
13786 
      iprot.readFieldEnd()
13787 
    iprot.readStructEnd()
13788 
 
13789 
  def write(self, oprot):
13790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13792 
      return
13793 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13794 
    if self.success is not None:
2616 chandransh 13795 
      oprot.writeFieldBegin('success', TType.I64, 0)
13796 
      oprot.writeI64(self.success)
13797 
      oprot.writeFieldEnd()
3431 rajveer 13798 
    if self.ex is not None:
2616 chandransh 13799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13800 
      self.ex.write(oprot)
13801 
      oprot.writeFieldEnd()
13802 
    oprot.writeFieldStop()
13803 
    oprot.writeStructEnd()
13804 
 
3431 rajveer 13805 
  def validate(self):
13806 
    return
13807 
 
13808 
 
2616 chandransh 13809 
  def __repr__(self):
13810 
    L = ['%s=%r' % (key, value)
13811 
      for key, value in self.__dict__.iteritems()]
13812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13813 
 
13814 
  def __eq__(self, other):
13815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13816 
 
13817 
  def __ne__(self, other):
13818 
    return not (self == other)
13819 
 
13820 
class refundOrder_args:
13821 
  """
13822 
  Attributes:
13823 
   - orderId
3226 chandransh 13824 
   - refundedBy
13825 
   - reason
2616 chandransh 13826 
  """
13827 
 
13828 
  thrift_spec = (
13829 
    None, # 0
13830 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13831 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13832 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13833 
  )
13834 
 
3226 chandransh 13835 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13836 
    self.orderId = orderId
3226 chandransh 13837 
    self.refundedBy = refundedBy
13838 
    self.reason = reason
2616 chandransh 13839 
 
13840 
  def read(self, iprot):
13841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13843 
      return
13844 
    iprot.readStructBegin()
13845 
    while True:
13846 
      (fname, ftype, fid) = iprot.readFieldBegin()
13847 
      if ftype == TType.STOP:
13848 
        break
13849 
      if fid == 1:
13850 
        if ftype == TType.I64:
13851 
          self.orderId = iprot.readI64();
13852 
        else:
13853 
          iprot.skip(ftype)
3226 chandransh 13854 
      elif fid == 2:
13855 
        if ftype == TType.STRING:
13856 
          self.refundedBy = iprot.readString();
13857 
        else:
13858 
          iprot.skip(ftype)
13859 
      elif fid == 3:
13860 
        if ftype == TType.STRING:
13861 
          self.reason = iprot.readString();
13862 
        else:
13863 
          iprot.skip(ftype)
2616 chandransh 13864 
      else:
13865 
        iprot.skip(ftype)
13866 
      iprot.readFieldEnd()
13867 
    iprot.readStructEnd()
13868 
 
13869 
  def write(self, oprot):
13870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13872 
      return
13873 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13874 
    if self.orderId is not None:
2616 chandransh 13875 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13876 
      oprot.writeI64(self.orderId)
13877 
      oprot.writeFieldEnd()
3431 rajveer 13878 
    if self.refundedBy is not None:
3226 chandransh 13879 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13880 
      oprot.writeString(self.refundedBy)
13881 
      oprot.writeFieldEnd()
3431 rajveer 13882 
    if self.reason is not None:
3226 chandransh 13883 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13884 
      oprot.writeString(self.reason)
13885 
      oprot.writeFieldEnd()
2616 chandransh 13886 
    oprot.writeFieldStop()
13887 
    oprot.writeStructEnd()
13888 
 
3431 rajveer 13889 
  def validate(self):
13890 
    return
13891 
 
13892 
 
2616 chandransh 13893 
  def __repr__(self):
13894 
    L = ['%s=%r' % (key, value)
13895 
      for key, value in self.__dict__.iteritems()]
13896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13897 
 
13898 
  def __eq__(self, other):
13899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13900 
 
13901 
  def __ne__(self, other):
13902 
    return not (self == other)
13903 
 
13904 
class refundOrder_result:
13905 
  """
13906 
  Attributes:
13907 
   - success
13908 
   - ex
13909 
  """
13910 
 
13911 
  thrift_spec = (
13912 
    (0, TType.BOOL, 'success', None, None, ), # 0
13913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13914 
  )
13915 
 
13916 
  def __init__(self, success=None, ex=None,):
13917 
    self.success = success
13918 
    self.ex = ex
13919 
 
13920 
  def read(self, iprot):
13921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13923 
      return
13924 
    iprot.readStructBegin()
13925 
    while True:
13926 
      (fname, ftype, fid) = iprot.readFieldBegin()
13927 
      if ftype == TType.STOP:
13928 
        break
13929 
      if fid == 0:
13930 
        if ftype == TType.BOOL:
13931 
          self.success = iprot.readBool();
13932 
        else:
13933 
          iprot.skip(ftype)
13934 
      elif fid == 1:
13935 
        if ftype == TType.STRUCT:
13936 
          self.ex = TransactionServiceException()
13937 
          self.ex.read(iprot)
13938 
        else:
13939 
          iprot.skip(ftype)
13940 
      else:
13941 
        iprot.skip(ftype)
13942 
      iprot.readFieldEnd()
13943 
    iprot.readStructEnd()
13944 
 
13945 
  def write(self, oprot):
13946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13948 
      return
13949 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13950 
    if self.success is not None:
2616 chandransh 13951 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13952 
      oprot.writeBool(self.success)
13953 
      oprot.writeFieldEnd()
3431 rajveer 13954 
    if self.ex is not None:
2616 chandransh 13955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13956 
      self.ex.write(oprot)
13957 
      oprot.writeFieldEnd()
13958 
    oprot.writeFieldStop()
13959 
    oprot.writeStructEnd()
13960 
 
3431 rajveer 13961 
  def validate(self):
13962 
    return
13963 
 
13964 
 
2616 chandransh 13965 
  def __repr__(self):
13966 
    L = ['%s=%r' % (key, value)
13967 
      for key, value in self.__dict__.iteritems()]
13968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13969 
 
13970 
  def __eq__(self, other):
13971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13972 
 
13973 
  def __ne__(self, other):
13974 
    return not (self == other)
13975 
 
2690 chandransh 13976 
class getReturnOrders_args:
13977 
  """
13978 
  Attributes:
13979 
   - warehouseId
13980 
   - fromDate
13981 
   - toDate
13982 
  """
2616 chandransh 13983 
 
2690 chandransh 13984 
  thrift_spec = (
13985 
    None, # 0
13986 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13987 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13988 
    (3, TType.I64, 'toDate', None, None, ), # 3
13989 
  )
13990 
 
13991 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13992 
    self.warehouseId = warehouseId
13993 
    self.fromDate = fromDate
13994 
    self.toDate = toDate
13995 
 
13996 
  def read(self, iprot):
13997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13999 
      return
14000 
    iprot.readStructBegin()
14001 
    while True:
14002 
      (fname, ftype, fid) = iprot.readFieldBegin()
14003 
      if ftype == TType.STOP:
14004 
        break
14005 
      if fid == 1:
14006 
        if ftype == TType.I64:
14007 
          self.warehouseId = iprot.readI64();
14008 
        else:
14009 
          iprot.skip(ftype)
14010 
      elif fid == 2:
14011 
        if ftype == TType.I64:
14012 
          self.fromDate = iprot.readI64();
14013 
        else:
14014 
          iprot.skip(ftype)
14015 
      elif fid == 3:
14016 
        if ftype == TType.I64:
14017 
          self.toDate = iprot.readI64();
14018 
        else:
14019 
          iprot.skip(ftype)
14020 
      else:
14021 
        iprot.skip(ftype)
14022 
      iprot.readFieldEnd()
14023 
    iprot.readStructEnd()
14024 
 
14025 
  def write(self, oprot):
14026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14028 
      return
14029 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14030 
    if self.warehouseId is not None:
2690 chandransh 14031 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14032 
      oprot.writeI64(self.warehouseId)
14033 
      oprot.writeFieldEnd()
3431 rajveer 14034 
    if self.fromDate is not None:
2690 chandransh 14035 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14036 
      oprot.writeI64(self.fromDate)
14037 
      oprot.writeFieldEnd()
3431 rajveer 14038 
    if self.toDate is not None:
2690 chandransh 14039 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14040 
      oprot.writeI64(self.toDate)
14041 
      oprot.writeFieldEnd()
14042 
    oprot.writeFieldStop()
14043 
    oprot.writeStructEnd()
14044 
 
3431 rajveer 14045 
  def validate(self):
14046 
    return
14047 
 
14048 
 
2690 chandransh 14049 
  def __repr__(self):
14050 
    L = ['%s=%r' % (key, value)
14051 
      for key, value in self.__dict__.iteritems()]
14052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14053 
 
14054 
  def __eq__(self, other):
14055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14056 
 
14057 
  def __ne__(self, other):
14058 
    return not (self == other)
14059 
 
14060 
class getReturnOrders_result:
14061 
  """
14062 
  Attributes:
14063 
   - success
14064 
  """
14065 
 
14066 
  thrift_spec = (
14067 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14068 
  )
14069 
 
14070 
  def __init__(self, success=None,):
14071 
    self.success = success
14072 
 
14073 
  def read(self, iprot):
14074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14076 
      return
14077 
    iprot.readStructBegin()
14078 
    while True:
14079 
      (fname, ftype, fid) = iprot.readFieldBegin()
14080 
      if ftype == TType.STOP:
14081 
        break
14082 
      if fid == 0:
14083 
        if ftype == TType.LIST:
14084 
          self.success = []
4741 phani.kuma 14085 
          (_etype232, _size229) = iprot.readListBegin()
14086 
          for _i233 in xrange(_size229):
14087 
            _elem234 = ReturnOrder()
14088 
            _elem234.read(iprot)
14089 
            self.success.append(_elem234)
2690 chandransh 14090 
          iprot.readListEnd()
14091 
        else:
14092 
          iprot.skip(ftype)
14093 
      else:
14094 
        iprot.skip(ftype)
14095 
      iprot.readFieldEnd()
14096 
    iprot.readStructEnd()
14097 
 
14098 
  def write(self, oprot):
14099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14101 
      return
14102 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14103 
    if self.success is not None:
2690 chandransh 14104 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14105 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 14106 
      for iter235 in self.success:
14107 
        iter235.write(oprot)
2690 chandransh 14108 
      oprot.writeListEnd()
14109 
      oprot.writeFieldEnd()
14110 
    oprot.writeFieldStop()
14111 
    oprot.writeStructEnd()
14112 
 
3431 rajveer 14113 
  def validate(self):
14114 
    return
14115 
 
14116 
 
2690 chandransh 14117 
  def __repr__(self):
14118 
    L = ['%s=%r' % (key, value)
14119 
      for key, value in self.__dict__.iteritems()]
14120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14121 
 
14122 
  def __eq__(self, other):
14123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14124 
 
14125 
  def __ne__(self, other):
14126 
    return not (self == other)
14127 
 
2700 chandransh 14128 
class getReturnOrder_args:
14129 
  """
14130 
  Attributes:
14131 
   - id
14132 
  """
14133 
 
14134 
  thrift_spec = (
14135 
    None, # 0
14136 
    (1, TType.I64, 'id', None, None, ), # 1
14137 
  )
14138 
 
14139 
  def __init__(self, id=None,):
14140 
    self.id = id
14141 
 
14142 
  def read(self, iprot):
14143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14145 
      return
14146 
    iprot.readStructBegin()
14147 
    while True:
14148 
      (fname, ftype, fid) = iprot.readFieldBegin()
14149 
      if ftype == TType.STOP:
14150 
        break
14151 
      if fid == 1:
14152 
        if ftype == TType.I64:
14153 
          self.id = iprot.readI64();
14154 
        else:
14155 
          iprot.skip(ftype)
14156 
      else:
14157 
        iprot.skip(ftype)
14158 
      iprot.readFieldEnd()
14159 
    iprot.readStructEnd()
14160 
 
14161 
  def write(self, oprot):
14162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14164 
      return
14165 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14166 
    if self.id is not None:
2700 chandransh 14167 
      oprot.writeFieldBegin('id', TType.I64, 1)
14168 
      oprot.writeI64(self.id)
14169 
      oprot.writeFieldEnd()
14170 
    oprot.writeFieldStop()
14171 
    oprot.writeStructEnd()
14172 
 
3431 rajveer 14173 
  def validate(self):
14174 
    return
14175 
 
14176 
 
2700 chandransh 14177 
  def __repr__(self):
14178 
    L = ['%s=%r' % (key, value)
14179 
      for key, value in self.__dict__.iteritems()]
14180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14181 
 
14182 
  def __eq__(self, other):
14183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14184 
 
14185 
  def __ne__(self, other):
14186 
    return not (self == other)
14187 
 
14188 
class getReturnOrder_result:
14189 
  """
14190 
  Attributes:
14191 
   - success
14192 
   - ex
14193 
  """
14194 
 
14195 
  thrift_spec = (
14196 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14198 
  )
14199 
 
14200 
  def __init__(self, success=None, ex=None,):
14201 
    self.success = success
14202 
    self.ex = ex
14203 
 
14204 
  def read(self, iprot):
14205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14207 
      return
14208 
    iprot.readStructBegin()
14209 
    while True:
14210 
      (fname, ftype, fid) = iprot.readFieldBegin()
14211 
      if ftype == TType.STOP:
14212 
        break
14213 
      if fid == 0:
14214 
        if ftype == TType.STRUCT:
14215 
          self.success = ReturnOrder()
14216 
          self.success.read(iprot)
14217 
        else:
14218 
          iprot.skip(ftype)
14219 
      elif fid == 1:
14220 
        if ftype == TType.STRUCT:
14221 
          self.ex = TransactionServiceException()
14222 
          self.ex.read(iprot)
14223 
        else:
14224 
          iprot.skip(ftype)
14225 
      else:
14226 
        iprot.skip(ftype)
14227 
      iprot.readFieldEnd()
14228 
    iprot.readStructEnd()
14229 
 
14230 
  def write(self, oprot):
14231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14233 
      return
14234 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14235 
    if self.success is not None:
2700 chandransh 14236 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14237 
      self.success.write(oprot)
14238 
      oprot.writeFieldEnd()
3431 rajveer 14239 
    if self.ex is not None:
2700 chandransh 14240 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14241 
      self.ex.write(oprot)
14242 
      oprot.writeFieldEnd()
14243 
    oprot.writeFieldStop()
14244 
    oprot.writeStructEnd()
14245 
 
3431 rajveer 14246 
  def validate(self):
14247 
    return
14248 
 
14249 
 
2700 chandransh 14250 
  def __repr__(self):
14251 
    L = ['%s=%r' % (key, value)
14252 
      for key, value in self.__dict__.iteritems()]
14253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14254 
 
14255 
  def __eq__(self, other):
14256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14257 
 
14258 
  def __ne__(self, other):
14259 
    return not (self == other)
14260 
 
2690 chandransh 14261 
class processReturn_args:
14262 
  """
14263 
  Attributes:
14264 
   - returnOrderId
14265 
  """
14266 
 
14267 
  thrift_spec = (
14268 
    None, # 0
14269 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14270 
  )
14271 
 
14272 
  def __init__(self, returnOrderId=None,):
14273 
    self.returnOrderId = returnOrderId
14274 
 
14275 
  def read(self, iprot):
14276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14278 
      return
14279 
    iprot.readStructBegin()
14280 
    while True:
14281 
      (fname, ftype, fid) = iprot.readFieldBegin()
14282 
      if ftype == TType.STOP:
14283 
        break
14284 
      if fid == 1:
14285 
        if ftype == TType.I64:
14286 
          self.returnOrderId = iprot.readI64();
14287 
        else:
14288 
          iprot.skip(ftype)
14289 
      else:
14290 
        iprot.skip(ftype)
14291 
      iprot.readFieldEnd()
14292 
    iprot.readStructEnd()
14293 
 
14294 
  def write(self, oprot):
14295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14297 
      return
14298 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14299 
    if self.returnOrderId is not None:
2690 chandransh 14300 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14301 
      oprot.writeI64(self.returnOrderId)
14302 
      oprot.writeFieldEnd()
14303 
    oprot.writeFieldStop()
14304 
    oprot.writeStructEnd()
14305 
 
3431 rajveer 14306 
  def validate(self):
14307 
    return
14308 
 
14309 
 
2690 chandransh 14310 
  def __repr__(self):
14311 
    L = ['%s=%r' % (key, value)
14312 
      for key, value in self.__dict__.iteritems()]
14313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14314 
 
14315 
  def __eq__(self, other):
14316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14317 
 
14318 
  def __ne__(self, other):
14319 
    return not (self == other)
14320 
 
14321 
class processReturn_result:
14322 
  """
14323 
  Attributes:
14324 
   - ex
14325 
  """
14326 
 
14327 
  thrift_spec = (
14328 
    None, # 0
14329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14330 
  )
14331 
 
14332 
  def __init__(self, ex=None,):
14333 
    self.ex = ex
14334 
 
14335 
  def read(self, iprot):
14336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14338 
      return
14339 
    iprot.readStructBegin()
14340 
    while True:
14341 
      (fname, ftype, fid) = iprot.readFieldBegin()
14342 
      if ftype == TType.STOP:
14343 
        break
14344 
      if fid == 1:
14345 
        if ftype == TType.STRUCT:
14346 
          self.ex = TransactionServiceException()
14347 
          self.ex.read(iprot)
14348 
        else:
14349 
          iprot.skip(ftype)
14350 
      else:
14351 
        iprot.skip(ftype)
14352 
      iprot.readFieldEnd()
14353 
    iprot.readStructEnd()
14354 
 
14355 
  def write(self, oprot):
14356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14358 
      return
14359 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14360 
    if self.ex is not None:
2690 chandransh 14361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14362 
      self.ex.write(oprot)
14363 
      oprot.writeFieldEnd()
14364 
    oprot.writeFieldStop()
14365 
    oprot.writeStructEnd()
14366 
 
3431 rajveer 14367 
  def validate(self):
14368 
    return
14369 
 
14370 
 
2690 chandransh 14371 
  def __repr__(self):
14372 
    L = ['%s=%r' % (key, value)
14373 
      for key, value in self.__dict__.iteritems()]
14374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14375 
 
14376 
  def __eq__(self, other):
14377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14378 
 
14379 
  def __ne__(self, other):
14380 
    return not (self == other)
14381 
 
2819 chandransh 14382 
class createPurchaseOrder_args:
14383 
  """
14384 
  Attributes:
14385 
   - warehouseId
14386 
  """
2690 chandransh 14387 
 
2819 chandransh 14388 
  thrift_spec = (
14389 
    None, # 0
14390 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14391 
  )
14392 
 
14393 
  def __init__(self, warehouseId=None,):
14394 
    self.warehouseId = warehouseId
14395 
 
14396 
  def read(self, iprot):
14397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14399 
      return
14400 
    iprot.readStructBegin()
14401 
    while True:
14402 
      (fname, ftype, fid) = iprot.readFieldBegin()
14403 
      if ftype == TType.STOP:
14404 
        break
14405 
      if fid == 1:
14406 
        if ftype == TType.I64:
14407 
          self.warehouseId = iprot.readI64();
14408 
        else:
14409 
          iprot.skip(ftype)
14410 
      else:
14411 
        iprot.skip(ftype)
14412 
      iprot.readFieldEnd()
14413 
    iprot.readStructEnd()
14414 
 
14415 
  def write(self, oprot):
14416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14418 
      return
14419 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 14420 
    if self.warehouseId is not None:
2819 chandransh 14421 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14422 
      oprot.writeI64(self.warehouseId)
14423 
      oprot.writeFieldEnd()
14424 
    oprot.writeFieldStop()
14425 
    oprot.writeStructEnd()
14426 
 
3431 rajveer 14427 
  def validate(self):
14428 
    return
14429 
 
14430 
 
2819 chandransh 14431 
  def __repr__(self):
14432 
    L = ['%s=%r' % (key, value)
14433 
      for key, value in self.__dict__.iteritems()]
14434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14435 
 
14436 
  def __eq__(self, other):
14437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14438 
 
14439 
  def __ne__(self, other):
14440 
    return not (self == other)
14441 
 
14442 
class createPurchaseOrder_result:
14443 
  """
14444 
  Attributes:
14445 
   - success
14446 
   - ex
14447 
  """
14448 
 
14449 
  thrift_spec = (
4586 mandeep.dh 14450 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 14451 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14452 
  )
14453 
 
14454 
  def __init__(self, success=None, ex=None,):
14455 
    self.success = success
14456 
    self.ex = ex
14457 
 
14458 
  def read(self, iprot):
14459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14461 
      return
14462 
    iprot.readStructBegin()
14463 
    while True:
14464 
      (fname, ftype, fid) = iprot.readFieldBegin()
14465 
      if ftype == TType.STOP:
14466 
        break
14467 
      if fid == 0:
4586 mandeep.dh 14468 
        if ftype == TType.LIST:
14469 
          self.success = []
4741 phani.kuma 14470 
          (_etype239, _size236) = iprot.readListBegin()
14471 
          for _i240 in xrange(_size236):
14472 
            _elem241 = iprot.readI64();
14473 
            self.success.append(_elem241)
4586 mandeep.dh 14474 
          iprot.readListEnd()
2819 chandransh 14475 
        else:
14476 
          iprot.skip(ftype)
14477 
      elif fid == 1:
14478 
        if ftype == TType.STRUCT:
14479 
          self.ex = TransactionServiceException()
14480 
          self.ex.read(iprot)
14481 
        else:
14482 
          iprot.skip(ftype)
14483 
      else:
14484 
        iprot.skip(ftype)
14485 
      iprot.readFieldEnd()
14486 
    iprot.readStructEnd()
14487 
 
14488 
  def write(self, oprot):
14489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14491 
      return
14492 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 14493 
    if self.success is not None:
4586 mandeep.dh 14494 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14495 
      oprot.writeListBegin(TType.I64, len(self.success))
4741 phani.kuma 14496 
      for iter242 in self.success:
14497 
        oprot.writeI64(iter242)
4586 mandeep.dh 14498 
      oprot.writeListEnd()
2819 chandransh 14499 
      oprot.writeFieldEnd()
3431 rajveer 14500 
    if self.ex is not None:
2819 chandransh 14501 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14502 
      self.ex.write(oprot)
14503 
      oprot.writeFieldEnd()
14504 
    oprot.writeFieldStop()
14505 
    oprot.writeStructEnd()
14506 
 
3431 rajveer 14507 
  def validate(self):
14508 
    return
14509 
 
14510 
 
2819 chandransh 14511 
  def __repr__(self):
14512 
    L = ['%s=%r' % (key, value)
14513 
      for key, value in self.__dict__.iteritems()]
14514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14515 
 
14516 
  def __eq__(self, other):
14517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14518 
 
14519 
  def __ne__(self, other):
14520 
    return not (self == other)
3451 chandransh 14521 
 
14522 
class updateWeight_args:
14523 
  """
14524 
  Attributes:
14525 
   - orderId
14526 
   - weight
14527 
  """
14528 
 
14529 
  thrift_spec = (
14530 
    None, # 0
14531 
    (1, TType.I64, 'orderId', None, None, ), # 1
14532 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14533 
  )
14534 
 
14535 
  def __init__(self, orderId=None, weight=None,):
14536 
    self.orderId = orderId
14537 
    self.weight = weight
14538 
 
14539 
  def read(self, iprot):
14540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14542 
      return
14543 
    iprot.readStructBegin()
14544 
    while True:
14545 
      (fname, ftype, fid) = iprot.readFieldBegin()
14546 
      if ftype == TType.STOP:
14547 
        break
14548 
      if fid == 1:
14549 
        if ftype == TType.I64:
14550 
          self.orderId = iprot.readI64();
14551 
        else:
14552 
          iprot.skip(ftype)
14553 
      elif fid == 2:
14554 
        if ftype == TType.DOUBLE:
14555 
          self.weight = iprot.readDouble();
14556 
        else:
14557 
          iprot.skip(ftype)
14558 
      else:
14559 
        iprot.skip(ftype)
14560 
      iprot.readFieldEnd()
14561 
    iprot.readStructEnd()
14562 
 
14563 
  def write(self, oprot):
14564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14566 
      return
14567 
    oprot.writeStructBegin('updateWeight_args')
14568 
    if self.orderId is not None:
14569 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14570 
      oprot.writeI64(self.orderId)
14571 
      oprot.writeFieldEnd()
14572 
    if self.weight is not None:
14573 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14574 
      oprot.writeDouble(self.weight)
14575 
      oprot.writeFieldEnd()
14576 
    oprot.writeFieldStop()
14577 
    oprot.writeStructEnd()
14578 
 
14579 
  def validate(self):
14580 
    return
14581 
 
14582 
 
14583 
  def __repr__(self):
14584 
    L = ['%s=%r' % (key, value)
14585 
      for key, value in self.__dict__.iteritems()]
14586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14587 
 
14588 
  def __eq__(self, other):
14589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14590 
 
14591 
  def __ne__(self, other):
14592 
    return not (self == other)
14593 
 
14594 
class updateWeight_result:
14595 
  """
14596 
  Attributes:
14597 
   - success
14598 
   - ex
14599 
  """
14600 
 
14601 
  thrift_spec = (
14602 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14604 
  )
14605 
 
14606 
  def __init__(self, success=None, ex=None,):
14607 
    self.success = success
14608 
    self.ex = ex
14609 
 
14610 
  def read(self, iprot):
14611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14613 
      return
14614 
    iprot.readStructBegin()
14615 
    while True:
14616 
      (fname, ftype, fid) = iprot.readFieldBegin()
14617 
      if ftype == TType.STOP:
14618 
        break
14619 
      if fid == 0:
14620 
        if ftype == TType.STRUCT:
14621 
          self.success = Order()
14622 
          self.success.read(iprot)
14623 
        else:
14624 
          iprot.skip(ftype)
14625 
      elif fid == 1:
14626 
        if ftype == TType.STRUCT:
14627 
          self.ex = TransactionServiceException()
14628 
          self.ex.read(iprot)
14629 
        else:
14630 
          iprot.skip(ftype)
14631 
      else:
14632 
        iprot.skip(ftype)
14633 
      iprot.readFieldEnd()
14634 
    iprot.readStructEnd()
14635 
 
14636 
  def write(self, oprot):
14637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14639 
      return
14640 
    oprot.writeStructBegin('updateWeight_result')
14641 
    if self.success is not None:
14642 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14643 
      self.success.write(oprot)
14644 
      oprot.writeFieldEnd()
14645 
    if self.ex is not None:
14646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14647 
      self.ex.write(oprot)
14648 
      oprot.writeFieldEnd()
14649 
    oprot.writeFieldStop()
14650 
    oprot.writeStructEnd()
14651 
 
14652 
  def validate(self):
14653 
    return
14654 
 
14655 
 
14656 
  def __repr__(self):
14657 
    L = ['%s=%r' % (key, value)
14658 
      for key, value in self.__dict__.iteritems()]
14659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14660 
 
14661 
  def __eq__(self, other):
14662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14663 
 
14664 
  def __ne__(self, other):
14665 
    return not (self == other)
3469 chandransh 14666 
 
14667 
class changeItem_args:
14668 
  """
14669 
  Attributes:
14670 
   - orderId
14671 
   - itemId
14672 
  """
14673 
 
14674 
  thrift_spec = (
14675 
    None, # 0
14676 
    (1, TType.I64, 'orderId', None, None, ), # 1
14677 
    (2, TType.I64, 'itemId', None, None, ), # 2
14678 
  )
14679 
 
14680 
  def __init__(self, orderId=None, itemId=None,):
14681 
    self.orderId = orderId
14682 
    self.itemId = itemId
14683 
 
14684 
  def read(self, iprot):
14685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14687 
      return
14688 
    iprot.readStructBegin()
14689 
    while True:
14690 
      (fname, ftype, fid) = iprot.readFieldBegin()
14691 
      if ftype == TType.STOP:
14692 
        break
14693 
      if fid == 1:
14694 
        if ftype == TType.I64:
14695 
          self.orderId = iprot.readI64();
14696 
        else:
14697 
          iprot.skip(ftype)
14698 
      elif fid == 2:
14699 
        if ftype == TType.I64:
14700 
          self.itemId = iprot.readI64();
14701 
        else:
14702 
          iprot.skip(ftype)
14703 
      else:
14704 
        iprot.skip(ftype)
14705 
      iprot.readFieldEnd()
14706 
    iprot.readStructEnd()
14707 
 
14708 
  def write(self, oprot):
14709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14711 
      return
14712 
    oprot.writeStructBegin('changeItem_args')
14713 
    if self.orderId is not None:
14714 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14715 
      oprot.writeI64(self.orderId)
14716 
      oprot.writeFieldEnd()
14717 
    if self.itemId is not None:
14718 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14719 
      oprot.writeI64(self.itemId)
14720 
      oprot.writeFieldEnd()
14721 
    oprot.writeFieldStop()
14722 
    oprot.writeStructEnd()
14723 
 
14724 
  def validate(self):
14725 
    return
14726 
 
14727 
 
14728 
  def __repr__(self):
14729 
    L = ['%s=%r' % (key, value)
14730 
      for key, value in self.__dict__.iteritems()]
14731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14732 
 
14733 
  def __eq__(self, other):
14734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14735 
 
14736 
  def __ne__(self, other):
14737 
    return not (self == other)
14738 
 
14739 
class changeItem_result:
14740 
  """
14741 
  Attributes:
14742 
   - success
14743 
   - ex
14744 
  """
14745 
 
14746 
  thrift_spec = (
14747 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14748 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14749 
  )
14750 
 
14751 
  def __init__(self, success=None, ex=None,):
14752 
    self.success = success
14753 
    self.ex = ex
14754 
 
14755 
  def read(self, iprot):
14756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14758 
      return
14759 
    iprot.readStructBegin()
14760 
    while True:
14761 
      (fname, ftype, fid) = iprot.readFieldBegin()
14762 
      if ftype == TType.STOP:
14763 
        break
14764 
      if fid == 0:
14765 
        if ftype == TType.STRUCT:
14766 
          self.success = Order()
14767 
          self.success.read(iprot)
14768 
        else:
14769 
          iprot.skip(ftype)
14770 
      elif fid == 1:
14771 
        if ftype == TType.STRUCT:
14772 
          self.ex = TransactionServiceException()
14773 
          self.ex.read(iprot)
14774 
        else:
14775 
          iprot.skip(ftype)
14776 
      else:
14777 
        iprot.skip(ftype)
14778 
      iprot.readFieldEnd()
14779 
    iprot.readStructEnd()
14780 
 
14781 
  def write(self, oprot):
14782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14784 
      return
14785 
    oprot.writeStructBegin('changeItem_result')
14786 
    if self.success is not None:
14787 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14788 
      self.success.write(oprot)
14789 
      oprot.writeFieldEnd()
14790 
    if self.ex is not None:
14791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14792 
      self.ex.write(oprot)
14793 
      oprot.writeFieldEnd()
14794 
    oprot.writeFieldStop()
14795 
    oprot.writeStructEnd()
14796 
 
14797 
  def validate(self):
14798 
    return
14799 
 
14800 
 
14801 
  def __repr__(self):
14802 
    L = ['%s=%r' % (key, value)
14803 
      for key, value in self.__dict__.iteritems()]
14804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14805 
 
14806 
  def __eq__(self, other):
14807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14808 
 
14809 
  def __ne__(self, other):
14810 
    return not (self == other)
14811 
 
14812 
class shiftToWarehouse_args:
14813 
  """
14814 
  Attributes:
14815 
   - orderId
14816 
   - warehouseId
14817 
  """
14818 
 
14819 
  thrift_spec = (
14820 
    None, # 0
14821 
    (1, TType.I64, 'orderId', None, None, ), # 1
14822 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14823 
  )
14824 
 
14825 
  def __init__(self, orderId=None, warehouseId=None,):
14826 
    self.orderId = orderId
14827 
    self.warehouseId = warehouseId
14828 
 
14829 
  def read(self, iprot):
14830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14832 
      return
14833 
    iprot.readStructBegin()
14834 
    while True:
14835 
      (fname, ftype, fid) = iprot.readFieldBegin()
14836 
      if ftype == TType.STOP:
14837 
        break
14838 
      if fid == 1:
14839 
        if ftype == TType.I64:
14840 
          self.orderId = iprot.readI64();
14841 
        else:
14842 
          iprot.skip(ftype)
14843 
      elif fid == 2:
14844 
        if ftype == TType.I64:
14845 
          self.warehouseId = iprot.readI64();
14846 
        else:
14847 
          iprot.skip(ftype)
14848 
      else:
14849 
        iprot.skip(ftype)
14850 
      iprot.readFieldEnd()
14851 
    iprot.readStructEnd()
14852 
 
14853 
  def write(self, oprot):
14854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14856 
      return
14857 
    oprot.writeStructBegin('shiftToWarehouse_args')
14858 
    if self.orderId is not None:
14859 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14860 
      oprot.writeI64(self.orderId)
14861 
      oprot.writeFieldEnd()
14862 
    if self.warehouseId is not None:
14863 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14864 
      oprot.writeI64(self.warehouseId)
14865 
      oprot.writeFieldEnd()
14866 
    oprot.writeFieldStop()
14867 
    oprot.writeStructEnd()
14868 
 
14869 
  def validate(self):
14870 
    return
14871 
 
14872 
 
14873 
  def __repr__(self):
14874 
    L = ['%s=%r' % (key, value)
14875 
      for key, value in self.__dict__.iteritems()]
14876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14877 
 
14878 
  def __eq__(self, other):
14879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14880 
 
14881 
  def __ne__(self, other):
14882 
    return not (self == other)
14883 
 
14884 
class shiftToWarehouse_result:
14885 
  """
14886 
  Attributes:
14887 
   - success
14888 
   - ex
14889 
  """
14890 
 
14891 
  thrift_spec = (
14892 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14894 
  )
14895 
 
14896 
  def __init__(self, success=None, ex=None,):
14897 
    self.success = success
14898 
    self.ex = ex
14899 
 
14900 
  def read(self, iprot):
14901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14903 
      return
14904 
    iprot.readStructBegin()
14905 
    while True:
14906 
      (fname, ftype, fid) = iprot.readFieldBegin()
14907 
      if ftype == TType.STOP:
14908 
        break
14909 
      if fid == 0:
14910 
        if ftype == TType.STRUCT:
14911 
          self.success = Order()
14912 
          self.success.read(iprot)
14913 
        else:
14914 
          iprot.skip(ftype)
14915 
      elif fid == 1:
14916 
        if ftype == TType.STRUCT:
14917 
          self.ex = TransactionServiceException()
14918 
          self.ex.read(iprot)
14919 
        else:
14920 
          iprot.skip(ftype)
14921 
      else:
14922 
        iprot.skip(ftype)
14923 
      iprot.readFieldEnd()
14924 
    iprot.readStructEnd()
14925 
 
14926 
  def write(self, oprot):
14927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14929 
      return
14930 
    oprot.writeStructBegin('shiftToWarehouse_result')
14931 
    if self.success is not None:
14932 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14933 
      self.success.write(oprot)
14934 
      oprot.writeFieldEnd()
14935 
    if self.ex is not None:
14936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14937 
      self.ex.write(oprot)
14938 
      oprot.writeFieldEnd()
14939 
    oprot.writeFieldStop()
14940 
    oprot.writeStructEnd()
14941 
 
14942 
  def validate(self):
14943 
    return
14944 
 
14945 
 
14946 
  def __repr__(self):
14947 
    L = ['%s=%r' % (key, value)
14948 
      for key, value in self.__dict__.iteritems()]
14949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14950 
 
14951 
  def __eq__(self, other):
14952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14953 
 
14954 
  def __ne__(self, other):
14955 
    return not (self == other)
3553 chandransh 14956 
 
14957 
class addDelayReason_args:
14958 
  """
14959 
  Attributes:
14960 
   - orderId
14961 
   - delayReason
3986 chandransh 14962 
   - furtherDelay
4647 rajveer 14963 
   - delayReasonText
3553 chandransh 14964 
  """
14965 
 
14966 
  thrift_spec = (
14967 
    None, # 0
14968 
    (1, TType.I64, 'orderId', None, None, ), # 1
14969 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14970 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14971 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14972 
  )
14973 
 
4647 rajveer 14974 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14975 
    self.orderId = orderId
14976 
    self.delayReason = delayReason
3986 chandransh 14977 
    self.furtherDelay = furtherDelay
4647 rajveer 14978 
    self.delayReasonText = delayReasonText
3553 chandransh 14979 
 
14980 
  def read(self, iprot):
14981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14983 
      return
14984 
    iprot.readStructBegin()
14985 
    while True:
14986 
      (fname, ftype, fid) = iprot.readFieldBegin()
14987 
      if ftype == TType.STOP:
14988 
        break
14989 
      if fid == 1:
14990 
        if ftype == TType.I64:
14991 
          self.orderId = iprot.readI64();
14992 
        else:
14993 
          iprot.skip(ftype)
14994 
      elif fid == 2:
14995 
        if ftype == TType.I32:
14996 
          self.delayReason = iprot.readI32();
14997 
        else:
14998 
          iprot.skip(ftype)
3986 chandransh 14999 
      elif fid == 3:
15000 
        if ftype == TType.I64:
15001 
          self.furtherDelay = iprot.readI64();
15002 
        else:
15003 
          iprot.skip(ftype)
4647 rajveer 15004 
      elif fid == 4:
15005 
        if ftype == TType.STRING:
15006 
          self.delayReasonText = iprot.readString();
15007 
        else:
15008 
          iprot.skip(ftype)
3553 chandransh 15009 
      else:
15010 
        iprot.skip(ftype)
15011 
      iprot.readFieldEnd()
15012 
    iprot.readStructEnd()
15013 
 
15014 
  def write(self, oprot):
15015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15017 
      return
15018 
    oprot.writeStructBegin('addDelayReason_args')
15019 
    if self.orderId is not None:
15020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15021 
      oprot.writeI64(self.orderId)
15022 
      oprot.writeFieldEnd()
15023 
    if self.delayReason is not None:
15024 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
15025 
      oprot.writeI32(self.delayReason)
15026 
      oprot.writeFieldEnd()
3986 chandransh 15027 
    if self.furtherDelay is not None:
15028 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
15029 
      oprot.writeI64(self.furtherDelay)
15030 
      oprot.writeFieldEnd()
4647 rajveer 15031 
    if self.delayReasonText is not None:
15032 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
15033 
      oprot.writeString(self.delayReasonText)
15034 
      oprot.writeFieldEnd()
3553 chandransh 15035 
    oprot.writeFieldStop()
15036 
    oprot.writeStructEnd()
15037 
 
15038 
  def validate(self):
15039 
    return
15040 
 
15041 
 
15042 
  def __repr__(self):
15043 
    L = ['%s=%r' % (key, value)
15044 
      for key, value in self.__dict__.iteritems()]
15045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15046 
 
15047 
  def __eq__(self, other):
15048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15049 
 
15050 
  def __ne__(self, other):
15051 
    return not (self == other)
15052 
 
15053 
class addDelayReason_result:
15054 
  """
15055 
  Attributes:
15056 
   - success
15057 
   - ex
15058 
  """
15059 
 
15060 
  thrift_spec = (
15061 
    (0, TType.BOOL, 'success', None, None, ), # 0
15062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15063 
  )
15064 
 
15065 
  def __init__(self, success=None, ex=None,):
15066 
    self.success = success
15067 
    self.ex = ex
15068 
 
15069 
  def read(self, iprot):
15070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15072 
      return
15073 
    iprot.readStructBegin()
15074 
    while True:
15075 
      (fname, ftype, fid) = iprot.readFieldBegin()
15076 
      if ftype == TType.STOP:
15077 
        break
15078 
      if fid == 0:
15079 
        if ftype == TType.BOOL:
15080 
          self.success = iprot.readBool();
15081 
        else:
15082 
          iprot.skip(ftype)
15083 
      elif fid == 1:
15084 
        if ftype == TType.STRUCT:
15085 
          self.ex = TransactionServiceException()
15086 
          self.ex.read(iprot)
15087 
        else:
15088 
          iprot.skip(ftype)
15089 
      else:
15090 
        iprot.skip(ftype)
15091 
      iprot.readFieldEnd()
15092 
    iprot.readStructEnd()
15093 
 
15094 
  def write(self, oprot):
15095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15097 
      return
15098 
    oprot.writeStructBegin('addDelayReason_result')
15099 
    if self.success is not None:
15100 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15101 
      oprot.writeBool(self.success)
15102 
      oprot.writeFieldEnd()
15103 
    if self.ex is not None:
15104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15105 
      self.ex.write(oprot)
15106 
      oprot.writeFieldEnd()
15107 
    oprot.writeFieldStop()
15108 
    oprot.writeStructEnd()
15109 
 
15110 
  def validate(self):
15111 
    return
15112 
 
15113 
 
15114 
  def __repr__(self):
15115 
    L = ['%s=%r' % (key, value)
15116 
      for key, value in self.__dict__.iteritems()]
15117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15118 
 
15119 
  def __eq__(self, other):
15120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15121 
 
15122 
  def __ne__(self, other):
15123 
    return not (self == other)
3956 chandransh 15124 
 
15125 
class reconcileCodCollection_args:
15126 
  """
15127 
  Attributes:
15128 
   - collectedAmountMap
15129 
   - xferBy
15130 
   - xferTxnId
15131 
   - xferDate
15132 
  """
15133 
 
15134 
  thrift_spec = (
15135 
    None, # 0
15136 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15137 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15138 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15139 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15140 
  )
15141 
 
15142 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15143 
    self.collectedAmountMap = collectedAmountMap
15144 
    self.xferBy = xferBy
15145 
    self.xferTxnId = xferTxnId
15146 
    self.xferDate = xferDate
15147 
 
15148 
  def read(self, iprot):
15149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15151 
      return
15152 
    iprot.readStructBegin()
15153 
    while True:
15154 
      (fname, ftype, fid) = iprot.readFieldBegin()
15155 
      if ftype == TType.STOP:
15156 
        break
15157 
      if fid == 1:
15158 
        if ftype == TType.MAP:
15159 
          self.collectedAmountMap = {}
4741 phani.kuma 15160 
          (_ktype244, _vtype245, _size243 ) = iprot.readMapBegin()
15161 
          for _i247 in xrange(_size243):
15162 
            _key248 = iprot.readString();
15163 
            _val249 = iprot.readDouble();
15164 
            self.collectedAmountMap[_key248] = _val249
3956 chandransh 15165 
          iprot.readMapEnd()
15166 
        else:
15167 
          iprot.skip(ftype)
15168 
      elif fid == 2:
15169 
        if ftype == TType.STRING:
15170 
          self.xferBy = iprot.readString();
15171 
        else:
15172 
          iprot.skip(ftype)
15173 
      elif fid == 3:
15174 
        if ftype == TType.STRING:
15175 
          self.xferTxnId = iprot.readString();
15176 
        else:
15177 
          iprot.skip(ftype)
15178 
      elif fid == 4:
15179 
        if ftype == TType.I64:
15180 
          self.xferDate = iprot.readI64();
15181 
        else:
15182 
          iprot.skip(ftype)
15183 
      else:
15184 
        iprot.skip(ftype)
15185 
      iprot.readFieldEnd()
15186 
    iprot.readStructEnd()
15187 
 
15188 
  def write(self, oprot):
15189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15191 
      return
15192 
    oprot.writeStructBegin('reconcileCodCollection_args')
15193 
    if self.collectedAmountMap is not None:
15194 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15195 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4741 phani.kuma 15196 
      for kiter250,viter251 in self.collectedAmountMap.items():
15197 
        oprot.writeString(kiter250)
15198 
        oprot.writeDouble(viter251)
3956 chandransh 15199 
      oprot.writeMapEnd()
15200 
      oprot.writeFieldEnd()
15201 
    if self.xferBy is not None:
15202 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15203 
      oprot.writeString(self.xferBy)
15204 
      oprot.writeFieldEnd()
15205 
    if self.xferTxnId is not None:
15206 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15207 
      oprot.writeString(self.xferTxnId)
15208 
      oprot.writeFieldEnd()
15209 
    if self.xferDate is not None:
15210 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15211 
      oprot.writeI64(self.xferDate)
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)
15230 
 
15231 
class reconcileCodCollection_result:
15232 
  """
15233 
  Attributes:
15234 
   - success
15235 
   - ex
15236 
  """
15237 
 
15238 
  thrift_spec = (
15239 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15240 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15241 
  )
15242 
 
15243 
  def __init__(self, success=None, ex=None,):
15244 
    self.success = success
15245 
    self.ex = ex
15246 
 
15247 
  def read(self, iprot):
15248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15250 
      return
15251 
    iprot.readStructBegin()
15252 
    while True:
15253 
      (fname, ftype, fid) = iprot.readFieldBegin()
15254 
      if ftype == TType.STOP:
15255 
        break
15256 
      if fid == 0:
15257 
        if ftype == TType.MAP:
15258 
          self.success = {}
4741 phani.kuma 15259 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
15260 
          for _i256 in xrange(_size252):
15261 
            _key257 = iprot.readString();
15262 
            _val258 = iprot.readString();
15263 
            self.success[_key257] = _val258
3956 chandransh 15264 
          iprot.readMapEnd()
15265 
        else:
15266 
          iprot.skip(ftype)
15267 
      elif fid == 1:
15268 
        if ftype == TType.STRUCT:
15269 
          self.ex = TransactionServiceException()
15270 
          self.ex.read(iprot)
15271 
        else:
15272 
          iprot.skip(ftype)
15273 
      else:
15274 
        iprot.skip(ftype)
15275 
      iprot.readFieldEnd()
15276 
    iprot.readStructEnd()
15277 
 
15278 
  def write(self, oprot):
15279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15281 
      return
15282 
    oprot.writeStructBegin('reconcileCodCollection_result')
15283 
    if self.success is not None:
15284 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15285 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4741 phani.kuma 15286 
      for kiter259,viter260 in self.success.items():
15287 
        oprot.writeString(kiter259)
15288 
        oprot.writeString(viter260)
3956 chandransh 15289 
      oprot.writeMapEnd()
15290 
      oprot.writeFieldEnd()
15291 
    if self.ex is not None:
15292 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15293 
      self.ex.write(oprot)
15294 
      oprot.writeFieldEnd()
15295 
    oprot.writeFieldStop()
15296 
    oprot.writeStructEnd()
15297 
 
15298 
  def validate(self):
15299 
    return
15300 
 
15301 
 
15302 
  def __repr__(self):
15303 
    L = ['%s=%r' % (key, value)
15304 
      for key, value in self.__dict__.iteritems()]
15305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15306 
 
15307 
  def __eq__(self, other):
15308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15309 
 
15310 
  def __ne__(self, other):
15311 
    return not (self == other)
4008 mandeep.dh 15312 
 
15313 
class getTransactionsRequiringExtraProcessing_args:
15314 
  """
15315 
  Attributes:
15316 
   - category
15317 
  """
15318 
 
15319 
  thrift_spec = (
15320 
    None, # 0
15321 
    (1, TType.I32, 'category', None, None, ), # 1
15322 
  )
15323 
 
15324 
  def __init__(self, category=None,):
15325 
    self.category = category
15326 
 
15327 
  def read(self, iprot):
15328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15330 
      return
15331 
    iprot.readStructBegin()
15332 
    while True:
15333 
      (fname, ftype, fid) = iprot.readFieldBegin()
15334 
      if ftype == TType.STOP:
15335 
        break
15336 
      if fid == 1:
15337 
        if ftype == TType.I32:
15338 
          self.category = iprot.readI32();
15339 
        else:
15340 
          iprot.skip(ftype)
15341 
      else:
15342 
        iprot.skip(ftype)
15343 
      iprot.readFieldEnd()
15344 
    iprot.readStructEnd()
15345 
 
15346 
  def write(self, oprot):
15347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15349 
      return
15350 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15351 
    if self.category is not None:
15352 
      oprot.writeFieldBegin('category', TType.I32, 1)
15353 
      oprot.writeI32(self.category)
15354 
      oprot.writeFieldEnd()
15355 
    oprot.writeFieldStop()
15356 
    oprot.writeStructEnd()
15357 
 
15358 
  def validate(self):
15359 
    return
15360 
 
15361 
 
15362 
  def __repr__(self):
15363 
    L = ['%s=%r' % (key, value)
15364 
      for key, value in self.__dict__.iteritems()]
15365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15366 
 
15367 
  def __eq__(self, other):
15368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15369 
 
15370 
  def __ne__(self, other):
15371 
    return not (self == other)
15372 
 
15373 
class getTransactionsRequiringExtraProcessing_result:
15374 
  """
15375 
  Attributes:
15376 
   - success
15377 
  """
15378 
 
15379 
  thrift_spec = (
15380 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15381 
  )
15382 
 
15383 
  def __init__(self, success=None,):
15384 
    self.success = success
15385 
 
15386 
  def read(self, iprot):
15387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15389 
      return
15390 
    iprot.readStructBegin()
15391 
    while True:
15392 
      (fname, ftype, fid) = iprot.readFieldBegin()
15393 
      if ftype == TType.STOP:
15394 
        break
15395 
      if fid == 0:
15396 
        if ftype == TType.LIST:
15397 
          self.success = []
4741 phani.kuma 15398 
          (_etype264, _size261) = iprot.readListBegin()
15399 
          for _i265 in xrange(_size261):
15400 
            _elem266 = iprot.readI64();
15401 
            self.success.append(_elem266)
4008 mandeep.dh 15402 
          iprot.readListEnd()
15403 
        else:
15404 
          iprot.skip(ftype)
15405 
      else:
15406 
        iprot.skip(ftype)
15407 
      iprot.readFieldEnd()
15408 
    iprot.readStructEnd()
15409 
 
15410 
  def write(self, oprot):
15411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15413 
      return
15414 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15415 
    if self.success is not None:
15416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15417 
      oprot.writeListBegin(TType.I64, len(self.success))
4741 phani.kuma 15418 
      for iter267 in self.success:
15419 
        oprot.writeI64(iter267)
4008 mandeep.dh 15420 
      oprot.writeListEnd()
15421 
      oprot.writeFieldEnd()
15422 
    oprot.writeFieldStop()
15423 
    oprot.writeStructEnd()
15424 
 
15425 
  def validate(self):
15426 
    return
15427 
 
15428 
 
15429 
  def __repr__(self):
15430 
    L = ['%s=%r' % (key, value)
15431 
      for key, value in self.__dict__.iteritems()]
15432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15433 
 
15434 
  def __eq__(self, other):
15435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15436 
 
15437 
  def __ne__(self, other):
15438 
    return not (self == other)
15439 
 
15440 
class markTransactionAsProcessed_args:
15441 
  """
15442 
  Attributes:
15443 
   - transactionId
15444 
   - category
15445 
  """
15446 
 
15447 
  thrift_spec = (
15448 
    None, # 0
15449 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15450 
    (2, TType.I32, 'category', None, None, ), # 2
15451 
  )
15452 
 
15453 
  def __init__(self, transactionId=None, category=None,):
15454 
    self.transactionId = transactionId
15455 
    self.category = category
15456 
 
15457 
  def read(self, iprot):
15458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15460 
      return
15461 
    iprot.readStructBegin()
15462 
    while True:
15463 
      (fname, ftype, fid) = iprot.readFieldBegin()
15464 
      if ftype == TType.STOP:
15465 
        break
15466 
      if fid == 1:
15467 
        if ftype == TType.I64:
15468 
          self.transactionId = iprot.readI64();
15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      elif fid == 2:
15472 
        if ftype == TType.I32:
15473 
          self.category = iprot.readI32();
15474 
        else:
15475 
          iprot.skip(ftype)
15476 
      else:
15477 
        iprot.skip(ftype)
15478 
      iprot.readFieldEnd()
15479 
    iprot.readStructEnd()
15480 
 
15481 
  def write(self, oprot):
15482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15484 
      return
15485 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15486 
    if self.transactionId is not None:
15487 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15488 
      oprot.writeI64(self.transactionId)
15489 
      oprot.writeFieldEnd()
15490 
    if self.category is not None:
15491 
      oprot.writeFieldBegin('category', TType.I32, 2)
15492 
      oprot.writeI32(self.category)
15493 
      oprot.writeFieldEnd()
15494 
    oprot.writeFieldStop()
15495 
    oprot.writeStructEnd()
15496 
 
15497 
  def validate(self):
15498 
    return
15499 
 
15500 
 
15501 
  def __repr__(self):
15502 
    L = ['%s=%r' % (key, value)
15503 
      for key, value in self.__dict__.iteritems()]
15504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15505 
 
15506 
  def __eq__(self, other):
15507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15508 
 
15509 
  def __ne__(self, other):
15510 
    return not (self == other)
15511 
 
15512 
class markTransactionAsProcessed_result:
15513 
 
15514 
  thrift_spec = (
15515 
  )
15516 
 
15517 
  def read(self, iprot):
15518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15520 
      return
15521 
    iprot.readStructBegin()
15522 
    while True:
15523 
      (fname, ftype, fid) = iprot.readFieldBegin()
15524 
      if ftype == TType.STOP:
15525 
        break
15526 
      else:
15527 
        iprot.skip(ftype)
15528 
      iprot.readFieldEnd()
15529 
    iprot.readStructEnd()
15530 
 
15531 
  def write(self, oprot):
15532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15534 
      return
15535 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15536 
    oprot.writeFieldStop()
15537 
    oprot.writeStructEnd()
15538 
 
15539 
  def validate(self):
15540 
    return
15541 
 
15542 
 
15543 
  def __repr__(self):
15544 
    L = ['%s=%r' % (key, value)
15545 
      for key, value in self.__dict__.iteritems()]
15546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15547 
 
15548 
  def __eq__(self, other):
15549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15550 
 
15551 
  def __ne__(self, other):
15552 
    return not (self == other)
4018 chandransh 15553 
 
15554 
class getItemWiseRiskyOrdersCount_args:
15555 
 
15556 
  thrift_spec = (
15557 
  )
15558 
 
15559 
  def read(self, iprot):
15560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15562 
      return
15563 
    iprot.readStructBegin()
15564 
    while True:
15565 
      (fname, ftype, fid) = iprot.readFieldBegin()
15566 
      if ftype == TType.STOP:
15567 
        break
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('getItemWiseRiskyOrdersCount_args')
15578 
    oprot.writeFieldStop()
15579 
    oprot.writeStructEnd()
15580 
 
15581 
  def validate(self):
15582 
    return
15583 
 
15584 
 
15585 
  def __repr__(self):
15586 
    L = ['%s=%r' % (key, value)
15587 
      for key, value in self.__dict__.iteritems()]
15588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15589 
 
15590 
  def __eq__(self, other):
15591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15592 
 
15593 
  def __ne__(self, other):
15594 
    return not (self == other)
15595 
 
15596 
class getItemWiseRiskyOrdersCount_result:
15597 
  """
15598 
  Attributes:
15599 
   - success
15600 
  """
15601 
 
15602 
  thrift_spec = (
15603 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15604 
  )
15605 
 
15606 
  def __init__(self, success=None,):
15607 
    self.success = success
15608 
 
15609 
  def read(self, iprot):
15610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15612 
      return
15613 
    iprot.readStructBegin()
15614 
    while True:
15615 
      (fname, ftype, fid) = iprot.readFieldBegin()
15616 
      if ftype == TType.STOP:
15617 
        break
15618 
      if fid == 0:
15619 
        if ftype == TType.MAP:
15620 
          self.success = {}
4741 phani.kuma 15621 
          (_ktype269, _vtype270, _size268 ) = iprot.readMapBegin()
15622 
          for _i272 in xrange(_size268):
15623 
            _key273 = iprot.readI64();
15624 
            _val274 = iprot.readI64();
15625 
            self.success[_key273] = _val274
4018 chandransh 15626 
          iprot.readMapEnd()
15627 
        else:
15628 
          iprot.skip(ftype)
15629 
      else:
15630 
        iprot.skip(ftype)
15631 
      iprot.readFieldEnd()
15632 
    iprot.readStructEnd()
15633 
 
15634 
  def write(self, oprot):
15635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15637 
      return
15638 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15639 
    if self.success is not None:
15640 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15641 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4741 phani.kuma 15642 
      for kiter275,viter276 in self.success.items():
15643 
        oprot.writeI64(kiter275)
15644 
        oprot.writeI64(viter276)
4018 chandransh 15645 
      oprot.writeMapEnd()
15646 
      oprot.writeFieldEnd()
15647 
    oprot.writeFieldStop()
15648 
    oprot.writeStructEnd()
15649 
 
15650 
  def validate(self):
15651 
    return
15652 
 
15653 
 
15654 
  def __repr__(self):
15655 
    L = ['%s=%r' % (key, value)
15656 
      for key, value in self.__dict__.iteritems()]
15657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15658 
 
15659 
  def __eq__(self, other):
15660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15661 
 
15662 
  def __ne__(self, other):
15663 
    return not (self == other)
4247 rajveer 15664 
 
4295 varun.gupt 15665 
class getOrdersForItemIds_args:
15666 
  """
15667 
  Attributes:
15668 
   - itemIds
15669 
  """
15670 
 
15671 
  thrift_spec = (
15672 
    None, # 0
15673 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15674 
  )
15675 
 
15676 
  def __init__(self, itemIds=None,):
15677 
    self.itemIds = itemIds
15678 
 
15679 
  def read(self, iprot):
15680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15682 
      return
15683 
    iprot.readStructBegin()
15684 
    while True:
15685 
      (fname, ftype, fid) = iprot.readFieldBegin()
15686 
      if ftype == TType.STOP:
15687 
        break
15688 
      if fid == 1:
15689 
        if ftype == TType.LIST:
15690 
          self.itemIds = []
4741 phani.kuma 15691 
          (_etype280, _size277) = iprot.readListBegin()
15692 
          for _i281 in xrange(_size277):
15693 
            _elem282 = iprot.readI64();
15694 
            self.itemIds.append(_elem282)
4295 varun.gupt 15695 
          iprot.readListEnd()
15696 
        else:
15697 
          iprot.skip(ftype)
15698 
      else:
15699 
        iprot.skip(ftype)
15700 
      iprot.readFieldEnd()
15701 
    iprot.readStructEnd()
15702 
 
15703 
  def write(self, oprot):
15704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15706 
      return
15707 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15708 
    if self.itemIds is not None:
15709 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15710 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4741 phani.kuma 15711 
      for iter283 in self.itemIds:
15712 
        oprot.writeI64(iter283)
4295 varun.gupt 15713 
      oprot.writeListEnd()
15714 
      oprot.writeFieldEnd()
15715 
    oprot.writeFieldStop()
15716 
    oprot.writeStructEnd()
15717 
 
15718 
  def validate(self):
15719 
    return
15720 
 
15721 
 
15722 
  def __repr__(self):
15723 
    L = ['%s=%r' % (key, value)
15724 
      for key, value in self.__dict__.iteritems()]
15725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15726 
 
15727 
  def __eq__(self, other):
15728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15729 
 
15730 
  def __ne__(self, other):
15731 
    return not (self == other)
15732 
 
15733 
class getOrdersForItemIds_result:
15734 
  """
15735 
  Attributes:
15736 
   - success
15737 
  """
15738 
 
15739 
  thrift_spec = (
15740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15741 
  )
15742 
 
15743 
  def __init__(self, success=None,):
15744 
    self.success = success
15745 
 
15746 
  def read(self, iprot):
15747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15749 
      return
15750 
    iprot.readStructBegin()
15751 
    while True:
15752 
      (fname, ftype, fid) = iprot.readFieldBegin()
15753 
      if ftype == TType.STOP:
15754 
        break
15755 
      if fid == 0:
15756 
        if ftype == TType.LIST:
15757 
          self.success = []
4741 phani.kuma 15758 
          (_etype287, _size284) = iprot.readListBegin()
15759 
          for _i288 in xrange(_size284):
15760 
            _elem289 = Order()
15761 
            _elem289.read(iprot)
15762 
            self.success.append(_elem289)
4295 varun.gupt 15763 
          iprot.readListEnd()
15764 
        else:
15765 
          iprot.skip(ftype)
15766 
      else:
15767 
        iprot.skip(ftype)
15768 
      iprot.readFieldEnd()
15769 
    iprot.readStructEnd()
15770 
 
15771 
  def write(self, oprot):
15772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15774 
      return
15775 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15776 
    if self.success is not None:
15777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 15779 
      for iter290 in self.success:
15780 
        iter290.write(oprot)
4295 varun.gupt 15781 
      oprot.writeListEnd()
15782 
      oprot.writeFieldEnd()
15783 
    oprot.writeFieldStop()
15784 
    oprot.writeStructEnd()
15785 
 
15786 
  def validate(self):
15787 
    return
15788 
 
15789 
 
15790 
  def __repr__(self):
15791 
    L = ['%s=%r' % (key, value)
15792 
      for key, value in self.__dict__.iteritems()]
15793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15794 
 
15795 
  def __eq__(self, other):
15796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15797 
 
15798 
  def __ne__(self, other):
15799 
    return not (self == other)
15800 
 
4247 rajveer 15801 
class markOrderCancellationRequestReceived_args:
15802 
  """
15803 
  Attributes:
15804 
   - orderId
15805 
  """
15806 
 
15807 
  thrift_spec = (
15808 
    None, # 0
15809 
    (1, TType.I64, 'orderId', None, None, ), # 1
15810 
  )
15811 
 
15812 
  def __init__(self, orderId=None,):
15813 
    self.orderId = orderId
15814 
 
15815 
  def read(self, iprot):
15816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15818 
      return
15819 
    iprot.readStructBegin()
15820 
    while True:
15821 
      (fname, ftype, fid) = iprot.readFieldBegin()
15822 
      if ftype == TType.STOP:
15823 
        break
15824 
      if fid == 1:
15825 
        if ftype == TType.I64:
15826 
          self.orderId = iprot.readI64();
15827 
        else:
15828 
          iprot.skip(ftype)
15829 
      else:
15830 
        iprot.skip(ftype)
15831 
      iprot.readFieldEnd()
15832 
    iprot.readStructEnd()
15833 
 
15834 
  def write(self, oprot):
15835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15837 
      return
15838 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15839 
    if self.orderId is not None:
15840 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15841 
      oprot.writeI64(self.orderId)
15842 
      oprot.writeFieldEnd()
15843 
    oprot.writeFieldStop()
15844 
    oprot.writeStructEnd()
15845 
 
15846 
  def validate(self):
15847 
    return
15848 
 
15849 
 
15850 
  def __repr__(self):
15851 
    L = ['%s=%r' % (key, value)
15852 
      for key, value in self.__dict__.iteritems()]
15853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15854 
 
15855 
  def __eq__(self, other):
15856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15857 
 
15858 
  def __ne__(self, other):
15859 
    return not (self == other)
15860 
 
15861 
class markOrderCancellationRequestReceived_result:
15862 
  """
15863 
  Attributes:
15864 
   - ex
15865 
  """
15866 
 
15867 
  thrift_spec = (
15868 
    None, # 0
15869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15870 
  )
15871 
 
15872 
  def __init__(self, ex=None,):
15873 
    self.ex = ex
15874 
 
15875 
  def read(self, iprot):
15876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15878 
      return
15879 
    iprot.readStructBegin()
15880 
    while True:
15881 
      (fname, ftype, fid) = iprot.readFieldBegin()
15882 
      if ftype == TType.STOP:
15883 
        break
15884 
      if fid == 1:
15885 
        if ftype == TType.STRUCT:
15886 
          self.ex = TransactionServiceException()
15887 
          self.ex.read(iprot)
15888 
        else:
15889 
          iprot.skip(ftype)
15890 
      else:
15891 
        iprot.skip(ftype)
15892 
      iprot.readFieldEnd()
15893 
    iprot.readStructEnd()
15894 
 
15895 
  def write(self, oprot):
15896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15898 
      return
15899 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15900 
    if self.ex is not None:
15901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15902 
      self.ex.write(oprot)
15903 
      oprot.writeFieldEnd()
15904 
    oprot.writeFieldStop()
15905 
    oprot.writeStructEnd()
15906 
 
15907 
  def validate(self):
15908 
    return
15909 
 
15910 
 
15911 
  def __repr__(self):
15912 
    L = ['%s=%r' % (key, value)
15913 
      for key, value in self.__dict__.iteritems()]
15914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15915 
 
15916 
  def __eq__(self, other):
15917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15918 
 
15919 
  def __ne__(self, other):
15920 
    return not (self == other)
15921 
 
15922 
class markOrderCancellationRequestConfirmed_args:
15923 
  """
15924 
  Attributes:
15925 
   - orderId
15926 
  """
15927 
 
15928 
  thrift_spec = (
15929 
    None, # 0
15930 
    (1, TType.I64, 'orderId', None, None, ), # 1
15931 
  )
15932 
 
15933 
  def __init__(self, orderId=None,):
15934 
    self.orderId = orderId
15935 
 
15936 
  def read(self, iprot):
15937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15939 
      return
15940 
    iprot.readStructBegin()
15941 
    while True:
15942 
      (fname, ftype, fid) = iprot.readFieldBegin()
15943 
      if ftype == TType.STOP:
15944 
        break
15945 
      if fid == 1:
15946 
        if ftype == TType.I64:
15947 
          self.orderId = iprot.readI64();
15948 
        else:
15949 
          iprot.skip(ftype)
15950 
      else:
15951 
        iprot.skip(ftype)
15952 
      iprot.readFieldEnd()
15953 
    iprot.readStructEnd()
15954 
 
15955 
  def write(self, oprot):
15956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15958 
      return
15959 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15960 
    if self.orderId is not None:
15961 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15962 
      oprot.writeI64(self.orderId)
15963 
      oprot.writeFieldEnd()
15964 
    oprot.writeFieldStop()
15965 
    oprot.writeStructEnd()
15966 
 
15967 
  def validate(self):
15968 
    return
15969 
 
15970 
 
15971 
  def __repr__(self):
15972 
    L = ['%s=%r' % (key, value)
15973 
      for key, value in self.__dict__.iteritems()]
15974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15975 
 
15976 
  def __eq__(self, other):
15977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15978 
 
15979 
  def __ne__(self, other):
15980 
    return not (self == other)
15981 
 
15982 
class markOrderCancellationRequestConfirmed_result:
15983 
  """
15984 
  Attributes:
15985 
   - ex
15986 
  """
15987 
 
15988 
  thrift_spec = (
15989 
    None, # 0
15990 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15991 
  )
15992 
 
15993 
  def __init__(self, ex=None,):
15994 
    self.ex = ex
15995 
 
15996 
  def read(self, iprot):
15997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15999 
      return
16000 
    iprot.readStructBegin()
16001 
    while True:
16002 
      (fname, ftype, fid) = iprot.readFieldBegin()
16003 
      if ftype == TType.STOP:
16004 
        break
16005 
      if fid == 1:
16006 
        if ftype == TType.STRUCT:
16007 
          self.ex = TransactionServiceException()
16008 
          self.ex.read(iprot)
16009 
        else:
16010 
          iprot.skip(ftype)
16011 
      else:
16012 
        iprot.skip(ftype)
16013 
      iprot.readFieldEnd()
16014 
    iprot.readStructEnd()
16015 
 
16016 
  def write(self, oprot):
16017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16019 
      return
16020 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
16021 
    if self.ex is not None:
16022 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16023 
      self.ex.write(oprot)
16024 
      oprot.writeFieldEnd()
16025 
    oprot.writeFieldStop()
16026 
    oprot.writeStructEnd()
16027 
 
16028 
  def validate(self):
16029 
    return
16030 
 
16031 
 
16032 
  def __repr__(self):
16033 
    L = ['%s=%r' % (key, value)
16034 
      for key, value in self.__dict__.iteritems()]
16035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16036 
 
16037 
  def __eq__(self, other):
16038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16039 
 
16040 
  def __ne__(self, other):
16041 
    return not (self == other)
16042 
 
16043 
class markOrderCancellationRequestDenied_args:
16044 
  """
16045 
  Attributes:
16046 
   - orderId
16047 
  """
16048 
 
16049 
  thrift_spec = (
16050 
    None, # 0
16051 
    (1, TType.I64, 'orderId', None, None, ), # 1
16052 
  )
16053 
 
16054 
  def __init__(self, orderId=None,):
16055 
    self.orderId = orderId
16056 
 
16057 
  def read(self, iprot):
16058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16060 
      return
16061 
    iprot.readStructBegin()
16062 
    while True:
16063 
      (fname, ftype, fid) = iprot.readFieldBegin()
16064 
      if ftype == TType.STOP:
16065 
        break
16066 
      if fid == 1:
16067 
        if ftype == TType.I64:
16068 
          self.orderId = iprot.readI64();
16069 
        else:
16070 
          iprot.skip(ftype)
16071 
      else:
16072 
        iprot.skip(ftype)
16073 
      iprot.readFieldEnd()
16074 
    iprot.readStructEnd()
16075 
 
16076 
  def write(self, oprot):
16077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16079 
      return
16080 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
16081 
    if self.orderId is not None:
16082 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16083 
      oprot.writeI64(self.orderId)
16084 
      oprot.writeFieldEnd()
16085 
    oprot.writeFieldStop()
16086 
    oprot.writeStructEnd()
16087 
 
16088 
  def validate(self):
16089 
    return
16090 
 
16091 
 
16092 
  def __repr__(self):
16093 
    L = ['%s=%r' % (key, value)
16094 
      for key, value in self.__dict__.iteritems()]
16095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16096 
 
16097 
  def __eq__(self, other):
16098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16099 
 
16100 
  def __ne__(self, other):
16101 
    return not (self == other)
16102 
 
16103 
class markOrderCancellationRequestDenied_result:
16104 
  """
16105 
  Attributes:
16106 
   - ex
16107 
  """
16108 
 
16109 
  thrift_spec = (
16110 
    None, # 0
16111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16112 
  )
16113 
 
16114 
  def __init__(self, ex=None,):
16115 
    self.ex = ex
16116 
 
16117 
  def read(self, iprot):
16118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16120 
      return
16121 
    iprot.readStructBegin()
16122 
    while True:
16123 
      (fname, ftype, fid) = iprot.readFieldBegin()
16124 
      if ftype == TType.STOP:
16125 
        break
16126 
      if fid == 1:
16127 
        if ftype == TType.STRUCT:
16128 
          self.ex = TransactionServiceException()
16129 
          self.ex.read(iprot)
16130 
        else:
16131 
          iprot.skip(ftype)
16132 
      else:
16133 
        iprot.skip(ftype)
16134 
      iprot.readFieldEnd()
16135 
    iprot.readStructEnd()
16136 
 
16137 
  def write(self, oprot):
16138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16140 
      return
16141 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16142 
    if self.ex is not None:
16143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16144 
      self.ex.write(oprot)
16145 
      oprot.writeFieldEnd()
16146 
    oprot.writeFieldStop()
16147 
    oprot.writeStructEnd()
16148 
 
16149 
  def validate(self):
16150 
    return
16151 
 
16152 
 
16153 
  def __repr__(self):
16154 
    L = ['%s=%r' % (key, value)
16155 
      for key, value in self.__dict__.iteritems()]
16156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16157 
 
16158 
  def __eq__(self, other):
16159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16160 
 
16161 
  def __ne__(self, other):
16162 
    return not (self == other)
16163 
 
4258 rajveer 16164 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16165 
  """
16166 
  Attributes:
4258 rajveer 16167 
   - transactionId
4247 rajveer 16168 
  """
16169 
 
16170 
  thrift_spec = (
16171 
    None, # 0
4258 rajveer 16172 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16173 
  )
16174 
 
4258 rajveer 16175 
  def __init__(self, transactionId=None,):
16176 
    self.transactionId = transactionId
4247 rajveer 16177 
 
16178 
  def read(self, iprot):
16179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16181 
      return
16182 
    iprot.readStructBegin()
16183 
    while True:
16184 
      (fname, ftype, fid) = iprot.readFieldBegin()
16185 
      if ftype == TType.STOP:
16186 
        break
16187 
      if fid == 1:
16188 
        if ftype == TType.I64:
4258 rajveer 16189 
          self.transactionId = iprot.readI64();
4247 rajveer 16190 
        else:
16191 
          iprot.skip(ftype)
16192 
      else:
16193 
        iprot.skip(ftype)
16194 
      iprot.readFieldEnd()
16195 
    iprot.readStructEnd()
16196 
 
16197 
  def write(self, oprot):
16198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16200 
      return
4258 rajveer 16201 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16202 
    if self.transactionId is not None:
16203 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16204 
      oprot.writeI64(self.transactionId)
4247 rajveer 16205 
      oprot.writeFieldEnd()
16206 
    oprot.writeFieldStop()
16207 
    oprot.writeStructEnd()
16208 
 
16209 
  def validate(self):
16210 
    return
16211 
 
16212 
 
16213 
  def __repr__(self):
16214 
    L = ['%s=%r' % (key, value)
16215 
      for key, value in self.__dict__.iteritems()]
16216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16217 
 
16218 
  def __eq__(self, other):
16219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16220 
 
16221 
  def __ne__(self, other):
16222 
    return not (self == other)
16223 
 
4258 rajveer 16224 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16225 
  """
16226 
  Attributes:
16227 
   - ex
16228 
  """
16229 
 
16230 
  thrift_spec = (
16231 
    None, # 0
16232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16233 
  )
16234 
 
16235 
  def __init__(self, ex=None,):
16236 
    self.ex = ex
16237 
 
16238 
  def read(self, iprot):
16239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16241 
      return
16242 
    iprot.readStructBegin()
16243 
    while True:
16244 
      (fname, ftype, fid) = iprot.readFieldBegin()
16245 
      if ftype == TType.STOP:
16246 
        break
16247 
      if fid == 1:
16248 
        if ftype == TType.STRUCT:
16249 
          self.ex = TransactionServiceException()
16250 
          self.ex.read(iprot)
16251 
        else:
16252 
          iprot.skip(ftype)
16253 
      else:
16254 
        iprot.skip(ftype)
16255 
      iprot.readFieldEnd()
16256 
    iprot.readStructEnd()
16257 
 
16258 
  def write(self, oprot):
16259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16261 
      return
4258 rajveer 16262 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16263 
    if self.ex is not None:
16264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16265 
      self.ex.write(oprot)
16266 
      oprot.writeFieldEnd()
16267 
    oprot.writeFieldStop()
16268 
    oprot.writeStructEnd()
16269 
 
16270 
  def validate(self):
16271 
    return
16272 
 
16273 
 
16274 
  def __repr__(self):
16275 
    L = ['%s=%r' % (key, value)
16276 
      for key, value in self.__dict__.iteritems()]
16277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16278 
 
16279 
  def __eq__(self, other):
16280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16281 
 
16282 
  def __ne__(self, other):
16283 
    return not (self == other)
4259 anupam.sin 16284 
 
16285 
class refundTransaction_args:
16286 
  """
16287 
  Attributes:
16288 
   - transactionId
16289 
   - refundedBy
16290 
   - reason
16291 
  """
16292 
 
16293 
  thrift_spec = (
16294 
    None, # 0
16295 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16296 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16297 
    (3, TType.STRING, 'reason', None, None, ), # 3
16298 
  )
16299 
 
16300 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16301 
    self.transactionId = transactionId
16302 
    self.refundedBy = refundedBy
16303 
    self.reason = reason
16304 
 
16305 
  def read(self, iprot):
16306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16308 
      return
16309 
    iprot.readStructBegin()
16310 
    while True:
16311 
      (fname, ftype, fid) = iprot.readFieldBegin()
16312 
      if ftype == TType.STOP:
16313 
        break
16314 
      if fid == 1:
16315 
        if ftype == TType.I64:
16316 
          self.transactionId = iprot.readI64();
16317 
        else:
16318 
          iprot.skip(ftype)
16319 
      elif fid == 2:
16320 
        if ftype == TType.STRING:
16321 
          self.refundedBy = iprot.readString();
16322 
        else:
16323 
          iprot.skip(ftype)
16324 
      elif fid == 3:
16325 
        if ftype == TType.STRING:
16326 
          self.reason = iprot.readString();
16327 
        else:
16328 
          iprot.skip(ftype)
16329 
      else:
16330 
        iprot.skip(ftype)
16331 
      iprot.readFieldEnd()
16332 
    iprot.readStructEnd()
16333 
 
16334 
  def write(self, oprot):
16335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16337 
      return
16338 
    oprot.writeStructBegin('refundTransaction_args')
16339 
    if self.transactionId is not None:
16340 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16341 
      oprot.writeI64(self.transactionId)
16342 
      oprot.writeFieldEnd()
16343 
    if self.refundedBy is not None:
16344 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16345 
      oprot.writeString(self.refundedBy)
16346 
      oprot.writeFieldEnd()
16347 
    if self.reason is not None:
16348 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16349 
      oprot.writeString(self.reason)
16350 
      oprot.writeFieldEnd()
16351 
    oprot.writeFieldStop()
16352 
    oprot.writeStructEnd()
16353 
 
16354 
  def validate(self):
16355 
    return
16356 
 
16357 
 
16358 
  def __repr__(self):
16359 
    L = ['%s=%r' % (key, value)
16360 
      for key, value in self.__dict__.iteritems()]
16361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16362 
 
16363 
  def __eq__(self, other):
16364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16365 
 
16366 
  def __ne__(self, other):
16367 
    return not (self == other)
16368 
 
16369 
class refundTransaction_result:
16370 
  """
16371 
  Attributes:
16372 
   - ex
16373 
  """
16374 
 
16375 
  thrift_spec = (
16376 
    None, # 0
16377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16378 
  )
16379 
 
16380 
  def __init__(self, ex=None,):
16381 
    self.ex = ex
16382 
 
16383 
  def read(self, iprot):
16384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16386 
      return
16387 
    iprot.readStructBegin()
16388 
    while True:
16389 
      (fname, ftype, fid) = iprot.readFieldBegin()
16390 
      if ftype == TType.STOP:
16391 
        break
16392 
      if fid == 1:
16393 
        if ftype == TType.STRUCT:
16394 
          self.ex = TransactionServiceException()
16395 
          self.ex.read(iprot)
16396 
        else:
16397 
          iprot.skip(ftype)
16398 
      else:
16399 
        iprot.skip(ftype)
16400 
      iprot.readFieldEnd()
16401 
    iprot.readStructEnd()
16402 
 
16403 
  def write(self, oprot):
16404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16406 
      return
16407 
    oprot.writeStructBegin('refundTransaction_result')
16408 
    if self.ex is not None:
16409 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16410 
      self.ex.write(oprot)
16411 
      oprot.writeFieldEnd()
16412 
    oprot.writeFieldStop()
16413 
    oprot.writeStructEnd()
16414 
 
16415 
  def validate(self):
16416 
    return
16417 
 
16418 
 
16419 
  def __repr__(self):
16420 
    L = ['%s=%r' % (key, value)
16421 
      for key, value in self.__dict__.iteritems()]
16422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16423 
 
16424 
  def __eq__(self, other):
16425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16426 
 
16427 
  def __ne__(self, other):
16428 
    return not (self == other)
4285 rajveer 16429 
 
4324 mandeep.dh 16430 
class updateShipmentAddress_args:
16431 
  """
16432 
  Attributes:
16433 
   - orderId
16434 
   - addressId
16435 
  """
16436 
 
16437 
  thrift_spec = (
16438 
    None, # 0
16439 
    (1, TType.I64, 'orderId', None, None, ), # 1
16440 
    (2, TType.I64, 'addressId', None, None, ), # 2
16441 
  )
16442 
 
16443 
  def __init__(self, orderId=None, addressId=None,):
16444 
    self.orderId = orderId
16445 
    self.addressId = addressId
16446 
 
16447 
  def read(self, iprot):
16448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16450 
      return
16451 
    iprot.readStructBegin()
16452 
    while True:
16453 
      (fname, ftype, fid) = iprot.readFieldBegin()
16454 
      if ftype == TType.STOP:
16455 
        break
16456 
      if fid == 1:
16457 
        if ftype == TType.I64:
16458 
          self.orderId = iprot.readI64();
16459 
        else:
16460 
          iprot.skip(ftype)
16461 
      elif fid == 2:
16462 
        if ftype == TType.I64:
16463 
          self.addressId = iprot.readI64();
16464 
        else:
16465 
          iprot.skip(ftype)
16466 
      else:
16467 
        iprot.skip(ftype)
16468 
      iprot.readFieldEnd()
16469 
    iprot.readStructEnd()
16470 
 
16471 
  def write(self, oprot):
16472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16474 
      return
16475 
    oprot.writeStructBegin('updateShipmentAddress_args')
16476 
    if self.orderId is not None:
16477 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16478 
      oprot.writeI64(self.orderId)
16479 
      oprot.writeFieldEnd()
16480 
    if self.addressId is not None:
16481 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16482 
      oprot.writeI64(self.addressId)
16483 
      oprot.writeFieldEnd()
16484 
    oprot.writeFieldStop()
16485 
    oprot.writeStructEnd()
16486 
 
16487 
  def validate(self):
16488 
    return
16489 
 
16490 
 
16491 
  def __repr__(self):
16492 
    L = ['%s=%r' % (key, value)
16493 
      for key, value in self.__dict__.iteritems()]
16494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16495 
 
16496 
  def __eq__(self, other):
16497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16498 
 
16499 
  def __ne__(self, other):
16500 
    return not (self == other)
16501 
 
16502 
class updateShipmentAddress_result:
16503 
  """
16504 
  Attributes:
16505 
   - ex
16506 
  """
16507 
 
16508 
  thrift_spec = (
16509 
    None, # 0
16510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16511 
  )
16512 
 
16513 
  def __init__(self, ex=None,):
16514 
    self.ex = ex
16515 
 
16516 
  def read(self, iprot):
16517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16519 
      return
16520 
    iprot.readStructBegin()
16521 
    while True:
16522 
      (fname, ftype, fid) = iprot.readFieldBegin()
16523 
      if ftype == TType.STOP:
16524 
        break
16525 
      if fid == 1:
16526 
        if ftype == TType.STRUCT:
16527 
          self.ex = TransactionServiceException()
16528 
          self.ex.read(iprot)
16529 
        else:
16530 
          iprot.skip(ftype)
16531 
      else:
16532 
        iprot.skip(ftype)
16533 
      iprot.readFieldEnd()
16534 
    iprot.readStructEnd()
16535 
 
16536 
  def write(self, oprot):
16537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16539 
      return
16540 
    oprot.writeStructBegin('updateShipmentAddress_result')
16541 
    if self.ex is not None:
16542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16543 
      self.ex.write(oprot)
16544 
      oprot.writeFieldEnd()
16545 
    oprot.writeFieldStop()
16546 
    oprot.writeStructEnd()
16547 
 
16548 
  def validate(self):
16549 
    return
16550 
 
16551 
 
16552 
  def __repr__(self):
16553 
    L = ['%s=%r' % (key, value)
16554 
      for key, value in self.__dict__.iteritems()]
16555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16556 
 
16557 
  def __eq__(self, other):
16558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16559 
 
16560 
  def __ne__(self, other):
16561 
    return not (self == other)
16562 
 
4285 rajveer 16563 
class acceptOrdersForItemId_args:
16564 
  """
16565 
  Attributes:
16566 
   - itemId
16567 
   - inventory
16568 
  """
16569 
 
16570 
  thrift_spec = (
16571 
    None, # 0
16572 
    (1, TType.I64, 'itemId', None, None, ), # 1
16573 
    (2, TType.I64, 'inventory', None, None, ), # 2
16574 
  )
16575 
 
16576 
  def __init__(self, itemId=None, inventory=None,):
16577 
    self.itemId = itemId
16578 
    self.inventory = inventory
16579 
 
16580 
  def read(self, iprot):
16581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16583 
      return
16584 
    iprot.readStructBegin()
16585 
    while True:
16586 
      (fname, ftype, fid) = iprot.readFieldBegin()
16587 
      if ftype == TType.STOP:
16588 
        break
16589 
      if fid == 1:
16590 
        if ftype == TType.I64:
16591 
          self.itemId = iprot.readI64();
16592 
        else:
16593 
          iprot.skip(ftype)
16594 
      elif fid == 2:
16595 
        if ftype == TType.I64:
16596 
          self.inventory = iprot.readI64();
16597 
        else:
16598 
          iprot.skip(ftype)
16599 
      else:
16600 
        iprot.skip(ftype)
16601 
      iprot.readFieldEnd()
16602 
    iprot.readStructEnd()
16603 
 
16604 
  def write(self, oprot):
16605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16607 
      return
16608 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16609 
    if self.itemId is not None:
16610 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16611 
      oprot.writeI64(self.itemId)
16612 
      oprot.writeFieldEnd()
16613 
    if self.inventory is not None:
16614 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16615 
      oprot.writeI64(self.inventory)
16616 
      oprot.writeFieldEnd()
16617 
    oprot.writeFieldStop()
16618 
    oprot.writeStructEnd()
16619 
 
16620 
  def validate(self):
16621 
    return
16622 
 
16623 
 
16624 
  def __repr__(self):
16625 
    L = ['%s=%r' % (key, value)
16626 
      for key, value in self.__dict__.iteritems()]
16627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16628 
 
16629 
  def __eq__(self, other):
16630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16631 
 
16632 
  def __ne__(self, other):
16633 
    return not (self == other)
16634 
 
16635 
class acceptOrdersForItemId_result:
16636 
  """
16637 
  Attributes:
16638 
   - success
16639 
   - ex
16640 
  """
16641 
 
16642 
  thrift_spec = (
16643 
    (0, TType.BOOL, 'success', None, None, ), # 0
16644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16645 
  )
16646 
 
16647 
  def __init__(self, success=None, ex=None,):
16648 
    self.success = success
16649 
    self.ex = ex
16650 
 
16651 
  def read(self, iprot):
16652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16654 
      return
16655 
    iprot.readStructBegin()
16656 
    while True:
16657 
      (fname, ftype, fid) = iprot.readFieldBegin()
16658 
      if ftype == TType.STOP:
16659 
        break
16660 
      if fid == 0:
16661 
        if ftype == TType.BOOL:
16662 
          self.success = iprot.readBool();
16663 
        else:
16664 
          iprot.skip(ftype)
16665 
      elif fid == 1:
16666 
        if ftype == TType.STRUCT:
16667 
          self.ex = TransactionServiceException()
16668 
          self.ex.read(iprot)
16669 
        else:
16670 
          iprot.skip(ftype)
16671 
      else:
16672 
        iprot.skip(ftype)
16673 
      iprot.readFieldEnd()
16674 
    iprot.readStructEnd()
16675 
 
16676 
  def write(self, oprot):
16677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16679 
      return
16680 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16681 
    if self.success is not None:
16682 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16683 
      oprot.writeBool(self.success)
16684 
      oprot.writeFieldEnd()
16685 
    if self.ex is not None:
16686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16687 
      self.ex.write(oprot)
16688 
      oprot.writeFieldEnd()
16689 
    oprot.writeFieldStop()
16690 
    oprot.writeStructEnd()
16691 
 
16692 
  def validate(self):
16693 
    return
16694 
 
16695 
 
16696 
  def __repr__(self):
16697 
    L = ['%s=%r' % (key, value)
16698 
      for key, value in self.__dict__.iteritems()]
16699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16700 
 
16701 
  def __eq__(self, other):
16702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16703 
 
16704 
  def __ne__(self, other):
16705 
    return not (self == other)
4303 rajveer 16706 
 
16707 
class markOrdersAsPORaised_args:
16708 
  """
16709 
  Attributes:
16710 
   - vendorId
16711 
   - itemId
16712 
   - quantity
16713 
   - estimate
4369 rajveer 16714 
   - isReminder
4303 rajveer 16715 
  """
16716 
 
16717 
  thrift_spec = (
16718 
    None, # 0
16719 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16720 
    (2, TType.I64, 'itemId', None, None, ), # 2
16721 
    (3, TType.I64, 'quantity', None, None, ), # 3
16722 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16723 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16724 
  )
16725 
 
4369 rajveer 16726 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16727 
    self.vendorId = vendorId
16728 
    self.itemId = itemId
16729 
    self.quantity = quantity
16730 
    self.estimate = estimate
4369 rajveer 16731 
    self.isReminder = isReminder
4303 rajveer 16732 
 
16733 
  def read(self, iprot):
16734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16736 
      return
16737 
    iprot.readStructBegin()
16738 
    while True:
16739 
      (fname, ftype, fid) = iprot.readFieldBegin()
16740 
      if ftype == TType.STOP:
16741 
        break
16742 
      if fid == 1:
16743 
        if ftype == TType.I64:
16744 
          self.vendorId = iprot.readI64();
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      elif fid == 2:
16748 
        if ftype == TType.I64:
16749 
          self.itemId = iprot.readI64();
16750 
        else:
16751 
          iprot.skip(ftype)
16752 
      elif fid == 3:
16753 
        if ftype == TType.I64:
16754 
          self.quantity = iprot.readI64();
16755 
        else:
16756 
          iprot.skip(ftype)
16757 
      elif fid == 4:
16758 
        if ftype == TType.I64:
16759 
          self.estimate = iprot.readI64();
16760 
        else:
16761 
          iprot.skip(ftype)
4369 rajveer 16762 
      elif fid == 5:
16763 
        if ftype == TType.BOOL:
16764 
          self.isReminder = iprot.readBool();
16765 
        else:
16766 
          iprot.skip(ftype)
4303 rajveer 16767 
      else:
16768 
        iprot.skip(ftype)
16769 
      iprot.readFieldEnd()
16770 
    iprot.readStructEnd()
16771 
 
16772 
  def write(self, oprot):
16773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16775 
      return
16776 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16777 
    if self.vendorId is not None:
16778 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16779 
      oprot.writeI64(self.vendorId)
16780 
      oprot.writeFieldEnd()
16781 
    if self.itemId is not None:
16782 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16783 
      oprot.writeI64(self.itemId)
16784 
      oprot.writeFieldEnd()
16785 
    if self.quantity is not None:
16786 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16787 
      oprot.writeI64(self.quantity)
16788 
      oprot.writeFieldEnd()
16789 
    if self.estimate is not None:
16790 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16791 
      oprot.writeI64(self.estimate)
16792 
      oprot.writeFieldEnd()
4369 rajveer 16793 
    if self.isReminder is not None:
16794 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16795 
      oprot.writeBool(self.isReminder)
16796 
      oprot.writeFieldEnd()
4303 rajveer 16797 
    oprot.writeFieldStop()
16798 
    oprot.writeStructEnd()
16799 
 
16800 
  def validate(self):
16801 
    return
16802 
 
16803 
 
16804 
  def __repr__(self):
16805 
    L = ['%s=%r' % (key, value)
16806 
      for key, value in self.__dict__.iteritems()]
16807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16808 
 
16809 
  def __eq__(self, other):
16810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16811 
 
16812 
  def __ne__(self, other):
16813 
    return not (self == other)
16814 
 
16815 
class markOrdersAsPORaised_result:
16816 
  """
16817 
  Attributes:
16818 
   - ex
16819 
  """
16820 
 
16821 
  thrift_spec = (
16822 
    None, # 0
16823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16824 
  )
16825 
 
16826 
  def __init__(self, ex=None,):
16827 
    self.ex = ex
16828 
 
16829 
  def read(self, iprot):
16830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16832 
      return
16833 
    iprot.readStructBegin()
16834 
    while True:
16835 
      (fname, ftype, fid) = iprot.readFieldBegin()
16836 
      if ftype == TType.STOP:
16837 
        break
16838 
      if fid == 1:
16839 
        if ftype == TType.STRUCT:
16840 
          self.ex = TransactionServiceException()
16841 
          self.ex.read(iprot)
16842 
        else:
16843 
          iprot.skip(ftype)
16844 
      else:
16845 
        iprot.skip(ftype)
16846 
      iprot.readFieldEnd()
16847 
    iprot.readStructEnd()
16848 
 
16849 
  def write(self, oprot):
16850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16852 
      return
16853 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16854 
    if self.ex is not None:
16855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16856 
      self.ex.write(oprot)
16857 
      oprot.writeFieldEnd()
16858 
    oprot.writeFieldStop()
16859 
    oprot.writeStructEnd()
16860 
 
16861 
  def validate(self):
16862 
    return
16863 
 
16864 
 
16865 
  def __repr__(self):
16866 
    L = ['%s=%r' % (key, value)
16867 
      for key, value in self.__dict__.iteritems()]
16868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16869 
 
16870 
  def __eq__(self, other):
16871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16872 
 
16873 
  def __ne__(self, other):
16874 
    return not (self == other)
16875 
 
16876 
class markOrdersAsReversalInitiated_args:
16877 
  """
16878 
  Attributes:
16879 
   - vendorId
16880 
   - itemId
16881 
   - quantity
16882 
   - estimate
4369 rajveer 16883 
   - isReminder
4303 rajveer 16884 
  """
16885 
 
16886 
  thrift_spec = (
16887 
    None, # 0
16888 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16889 
    (2, TType.I64, 'itemId', None, None, ), # 2
16890 
    (3, TType.I64, 'quantity', None, None, ), # 3
16891 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16892 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16893 
  )
16894 
 
4369 rajveer 16895 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16896 
    self.vendorId = vendorId
16897 
    self.itemId = itemId
16898 
    self.quantity = quantity
16899 
    self.estimate = estimate
4369 rajveer 16900 
    self.isReminder = isReminder
4303 rajveer 16901 
 
16902 
  def read(self, iprot):
16903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16905 
      return
16906 
    iprot.readStructBegin()
16907 
    while True:
16908 
      (fname, ftype, fid) = iprot.readFieldBegin()
16909 
      if ftype == TType.STOP:
16910 
        break
16911 
      if fid == 1:
16912 
        if ftype == TType.I64:
16913 
          self.vendorId = iprot.readI64();
16914 
        else:
16915 
          iprot.skip(ftype)
16916 
      elif fid == 2:
16917 
        if ftype == TType.I64:
16918 
          self.itemId = iprot.readI64();
16919 
        else:
16920 
          iprot.skip(ftype)
16921 
      elif fid == 3:
16922 
        if ftype == TType.I64:
16923 
          self.quantity = iprot.readI64();
16924 
        else:
16925 
          iprot.skip(ftype)
16926 
      elif fid == 4:
16927 
        if ftype == TType.I64:
16928 
          self.estimate = iprot.readI64();
16929 
        else:
16930 
          iprot.skip(ftype)
4369 rajveer 16931 
      elif fid == 5:
16932 
        if ftype == TType.BOOL:
16933 
          self.isReminder = iprot.readBool();
16934 
        else:
16935 
          iprot.skip(ftype)
4303 rajveer 16936 
      else:
16937 
        iprot.skip(ftype)
16938 
      iprot.readFieldEnd()
16939 
    iprot.readStructEnd()
16940 
 
16941 
  def write(self, oprot):
16942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16944 
      return
16945 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16946 
    if self.vendorId is not None:
16947 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16948 
      oprot.writeI64(self.vendorId)
16949 
      oprot.writeFieldEnd()
16950 
    if self.itemId is not None:
16951 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16952 
      oprot.writeI64(self.itemId)
16953 
      oprot.writeFieldEnd()
16954 
    if self.quantity is not None:
16955 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16956 
      oprot.writeI64(self.quantity)
16957 
      oprot.writeFieldEnd()
16958 
    if self.estimate is not None:
16959 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16960 
      oprot.writeI64(self.estimate)
16961 
      oprot.writeFieldEnd()
4369 rajveer 16962 
    if self.isReminder is not None:
16963 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16964 
      oprot.writeBool(self.isReminder)
16965 
      oprot.writeFieldEnd()
4303 rajveer 16966 
    oprot.writeFieldStop()
16967 
    oprot.writeStructEnd()
16968 
 
16969 
  def validate(self):
16970 
    return
16971 
 
16972 
 
16973 
  def __repr__(self):
16974 
    L = ['%s=%r' % (key, value)
16975 
      for key, value in self.__dict__.iteritems()]
16976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16977 
 
16978 
  def __eq__(self, other):
16979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16980 
 
16981 
  def __ne__(self, other):
16982 
    return not (self == other)
16983 
 
16984 
class markOrdersAsReversalInitiated_result:
16985 
  """
16986 
  Attributes:
16987 
   - ex
16988 
  """
16989 
 
16990 
  thrift_spec = (
16991 
    None, # 0
16992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16993 
  )
16994 
 
16995 
  def __init__(self, ex=None,):
16996 
    self.ex = ex
16997 
 
16998 
  def read(self, iprot):
16999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17001 
      return
17002 
    iprot.readStructBegin()
17003 
    while True:
17004 
      (fname, ftype, fid) = iprot.readFieldBegin()
17005 
      if ftype == TType.STOP:
17006 
        break
17007 
      if fid == 1:
17008 
        if ftype == TType.STRUCT:
17009 
          self.ex = TransactionServiceException()
17010 
          self.ex.read(iprot)
17011 
        else:
17012 
          iprot.skip(ftype)
17013 
      else:
17014 
        iprot.skip(ftype)
17015 
      iprot.readFieldEnd()
17016 
    iprot.readStructEnd()
17017 
 
17018 
  def write(self, oprot):
17019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17021 
      return
17022 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
17023 
    if self.ex is not None:
17024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17025 
      self.ex.write(oprot)
17026 
      oprot.writeFieldEnd()
17027 
    oprot.writeFieldStop()
17028 
    oprot.writeStructEnd()
17029 
 
17030 
  def validate(self):
17031 
    return
17032 
 
17033 
 
17034 
  def __repr__(self):
17035 
    L = ['%s=%r' % (key, value)
17036 
      for key, value in self.__dict__.iteritems()]
17037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17038 
 
17039 
  def __eq__(self, other):
17040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17041 
 
17042 
  def __ne__(self, other):
17043 
    return not (self == other)
17044 
 
17045 
class markOrdersAsNotAvailabke_args:
17046 
  """
17047 
  Attributes:
17048 
   - vendorId
17049 
   - itemId
17050 
   - quantity
17051 
   - estimate
4369 rajveer 17052 
   - isReminder
4303 rajveer 17053 
  """
17054 
 
17055 
  thrift_spec = (
17056 
    None, # 0
17057 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17058 
    (2, TType.I64, 'itemId', None, None, ), # 2
17059 
    (3, TType.I64, 'quantity', None, None, ), # 3
17060 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17061 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17062 
  )
17063 
 
4369 rajveer 17064 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17065 
    self.vendorId = vendorId
17066 
    self.itemId = itemId
17067 
    self.quantity = quantity
17068 
    self.estimate = estimate
4369 rajveer 17069 
    self.isReminder = isReminder
4303 rajveer 17070 
 
17071 
  def read(self, iprot):
17072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17074 
      return
17075 
    iprot.readStructBegin()
17076 
    while True:
17077 
      (fname, ftype, fid) = iprot.readFieldBegin()
17078 
      if ftype == TType.STOP:
17079 
        break
17080 
      if fid == 1:
17081 
        if ftype == TType.I64:
17082 
          self.vendorId = iprot.readI64();
17083 
        else:
17084 
          iprot.skip(ftype)
17085 
      elif fid == 2:
17086 
        if ftype == TType.I64:
17087 
          self.itemId = iprot.readI64();
17088 
        else:
17089 
          iprot.skip(ftype)
17090 
      elif fid == 3:
17091 
        if ftype == TType.I64:
17092 
          self.quantity = iprot.readI64();
17093 
        else:
17094 
          iprot.skip(ftype)
17095 
      elif fid == 4:
17096 
        if ftype == TType.I64:
17097 
          self.estimate = iprot.readI64();
17098 
        else:
17099 
          iprot.skip(ftype)
4369 rajveer 17100 
      elif fid == 5:
17101 
        if ftype == TType.BOOL:
17102 
          self.isReminder = iprot.readBool();
17103 
        else:
17104 
          iprot.skip(ftype)
4303 rajveer 17105 
      else:
17106 
        iprot.skip(ftype)
17107 
      iprot.readFieldEnd()
17108 
    iprot.readStructEnd()
17109 
 
17110 
  def write(self, oprot):
17111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17113 
      return
17114 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17115 
    if self.vendorId is not None:
17116 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17117 
      oprot.writeI64(self.vendorId)
17118 
      oprot.writeFieldEnd()
17119 
    if self.itemId is not None:
17120 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17121 
      oprot.writeI64(self.itemId)
17122 
      oprot.writeFieldEnd()
17123 
    if self.quantity is not None:
17124 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17125 
      oprot.writeI64(self.quantity)
17126 
      oprot.writeFieldEnd()
17127 
    if self.estimate is not None:
17128 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17129 
      oprot.writeI64(self.estimate)
17130 
      oprot.writeFieldEnd()
4369 rajveer 17131 
    if self.isReminder is not None:
17132 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17133 
      oprot.writeBool(self.isReminder)
17134 
      oprot.writeFieldEnd()
4303 rajveer 17135 
    oprot.writeFieldStop()
17136 
    oprot.writeStructEnd()
17137 
 
17138 
  def validate(self):
17139 
    return
17140 
 
17141 
 
17142 
  def __repr__(self):
17143 
    L = ['%s=%r' % (key, value)
17144 
      for key, value in self.__dict__.iteritems()]
17145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17146 
 
17147 
  def __eq__(self, other):
17148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17149 
 
17150 
  def __ne__(self, other):
17151 
    return not (self == other)
17152 
 
17153 
class markOrdersAsNotAvailabke_result:
17154 
  """
17155 
  Attributes:
17156 
   - ex
17157 
  """
17158 
 
17159 
  thrift_spec = (
17160 
    None, # 0
17161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17162 
  )
17163 
 
17164 
  def __init__(self, ex=None,):
17165 
    self.ex = ex
17166 
 
17167 
  def read(self, iprot):
17168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17170 
      return
17171 
    iprot.readStructBegin()
17172 
    while True:
17173 
      (fname, ftype, fid) = iprot.readFieldBegin()
17174 
      if ftype == TType.STOP:
17175 
        break
17176 
      if fid == 1:
17177 
        if ftype == TType.STRUCT:
17178 
          self.ex = TransactionServiceException()
17179 
          self.ex.read(iprot)
17180 
        else:
17181 
          iprot.skip(ftype)
17182 
      else:
17183 
        iprot.skip(ftype)
17184 
      iprot.readFieldEnd()
17185 
    iprot.readStructEnd()
17186 
 
17187 
  def write(self, oprot):
17188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17190 
      return
17191 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17192 
    if self.ex is not None:
17193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17194 
      self.ex.write(oprot)
17195 
      oprot.writeFieldEnd()
17196 
    oprot.writeFieldStop()
17197 
    oprot.writeStructEnd()
17198 
 
17199 
  def validate(self):
17200 
    return
17201 
 
17202 
 
17203 
  def __repr__(self):
17204 
    L = ['%s=%r' % (key, value)
17205 
      for key, value in self.__dict__.iteritems()]
17206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17207 
 
17208 
  def __eq__(self, other):
17209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17210 
 
17211 
  def __ne__(self, other):
17212 
    return not (self == other)
4369 rajveer 17213 
 
17214 
class markOrdersAsTimeout_args:
17215 
  """
17216 
  Attributes:
17217 
   - vendorId
17218 
  """
17219 
 
17220 
  thrift_spec = (
17221 
    None, # 0
17222 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17223 
  )
17224 
 
17225 
  def __init__(self, vendorId=None,):
17226 
    self.vendorId = vendorId
17227 
 
17228 
  def read(self, iprot):
17229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17231 
      return
17232 
    iprot.readStructBegin()
17233 
    while True:
17234 
      (fname, ftype, fid) = iprot.readFieldBegin()
17235 
      if ftype == TType.STOP:
17236 
        break
17237 
      if fid == 1:
17238 
        if ftype == TType.I64:
17239 
          self.vendorId = iprot.readI64();
17240 
        else:
17241 
          iprot.skip(ftype)
17242 
      else:
17243 
        iprot.skip(ftype)
17244 
      iprot.readFieldEnd()
17245 
    iprot.readStructEnd()
17246 
 
17247 
  def write(self, oprot):
17248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17250 
      return
17251 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17252 
    if self.vendorId is not None:
17253 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17254 
      oprot.writeI64(self.vendorId)
17255 
      oprot.writeFieldEnd()
17256 
    oprot.writeFieldStop()
17257 
    oprot.writeStructEnd()
17258 
 
17259 
  def validate(self):
17260 
    return
17261 
 
17262 
 
17263 
  def __repr__(self):
17264 
    L = ['%s=%r' % (key, value)
17265 
      for key, value in self.__dict__.iteritems()]
17266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17267 
 
17268 
  def __eq__(self, other):
17269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17270 
 
17271 
  def __ne__(self, other):
17272 
    return not (self == other)
17273 
 
17274 
class markOrdersAsTimeout_result:
17275 
  """
17276 
  Attributes:
17277 
   - success
17278 
   - ex
17279 
  """
17280 
 
17281 
  thrift_spec = (
17282 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17284 
  )
17285 
 
17286 
  def __init__(self, success=None, ex=None,):
17287 
    self.success = success
17288 
    self.ex = ex
17289 
 
17290 
  def read(self, iprot):
17291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17293 
      return
17294 
    iprot.readStructBegin()
17295 
    while True:
17296 
      (fname, ftype, fid) = iprot.readFieldBegin()
17297 
      if ftype == TType.STOP:
17298 
        break
17299 
      if fid == 0:
17300 
        if ftype == TType.MAP:
17301 
          self.success = {}
4741 phani.kuma 17302 
          (_ktype292, _vtype293, _size291 ) = iprot.readMapBegin()
17303 
          for _i295 in xrange(_size291):
17304 
            _key296 = iprot.readI32();
17305 
            _val297 = TimeoutSummary()
17306 
            _val297.read(iprot)
17307 
            self.success[_key296] = _val297
4369 rajveer 17308 
          iprot.readMapEnd()
17309 
        else:
17310 
          iprot.skip(ftype)
17311 
      elif fid == 1:
17312 
        if ftype == TType.STRUCT:
17313 
          self.ex = TransactionServiceException()
17314 
          self.ex.read(iprot)
17315 
        else:
17316 
          iprot.skip(ftype)
17317 
      else:
17318 
        iprot.skip(ftype)
17319 
      iprot.readFieldEnd()
17320 
    iprot.readStructEnd()
17321 
 
17322 
  def write(self, oprot):
17323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17325 
      return
17326 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17327 
    if self.success is not None:
17328 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17329 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4741 phani.kuma 17330 
      for kiter298,viter299 in self.success.items():
17331 
        oprot.writeI32(kiter298)
17332 
        viter299.write(oprot)
4369 rajveer 17333 
      oprot.writeMapEnd()
17334 
      oprot.writeFieldEnd()
17335 
    if self.ex is not None:
17336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17337 
      self.ex.write(oprot)
17338 
      oprot.writeFieldEnd()
17339 
    oprot.writeFieldStop()
17340 
    oprot.writeStructEnd()
17341 
 
17342 
  def validate(self):
17343 
    return
17344 
 
17345 
 
17346 
  def __repr__(self):
17347 
    L = ['%s=%r' % (key, value)
17348 
      for key, value in self.__dict__.iteritems()]
17349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17350 
 
17351 
  def __eq__(self, other):
17352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17353 
 
17354 
  def __ne__(self, other):
17355 
    return not (self == other)
4386 anupam.sin 17356 
 
4662 rajveer 17357 
class markOrderAsLostInTransit_args:
17358 
  """
17359 
  Attributes:
17360 
   - orderId
17361 
  """
17362 
 
17363 
  thrift_spec = (
17364 
    None, # 0
17365 
    (1, TType.I64, 'orderId', None, None, ), # 1
17366 
  )
17367 
 
17368 
  def __init__(self, orderId=None,):
17369 
    self.orderId = orderId
17370 
 
17371 
  def read(self, iprot):
17372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17374 
      return
17375 
    iprot.readStructBegin()
17376 
    while True:
17377 
      (fname, ftype, fid) = iprot.readFieldBegin()
17378 
      if ftype == TType.STOP:
17379 
        break
17380 
      if fid == 1:
17381 
        if ftype == TType.I64:
17382 
          self.orderId = iprot.readI64();
17383 
        else:
17384 
          iprot.skip(ftype)
17385 
      else:
17386 
        iprot.skip(ftype)
17387 
      iprot.readFieldEnd()
17388 
    iprot.readStructEnd()
17389 
 
17390 
  def write(self, oprot):
17391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17393 
      return
17394 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17395 
    if self.orderId is not None:
17396 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17397 
      oprot.writeI64(self.orderId)
17398 
      oprot.writeFieldEnd()
17399 
    oprot.writeFieldStop()
17400 
    oprot.writeStructEnd()
17401 
 
17402 
  def validate(self):
17403 
    return
17404 
 
17405 
 
17406 
  def __repr__(self):
17407 
    L = ['%s=%r' % (key, value)
17408 
      for key, value in self.__dict__.iteritems()]
17409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17410 
 
17411 
  def __eq__(self, other):
17412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17413 
 
17414 
  def __ne__(self, other):
17415 
    return not (self == other)
17416 
 
17417 
class markOrderAsLostInTransit_result:
17418 
  """
17419 
  Attributes:
17420 
   - success
17421 
   - ex
17422 
  """
17423 
 
17424 
  thrift_spec = (
17425 
    (0, TType.BOOL, 'success', None, None, ), # 0
17426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17427 
  )
17428 
 
17429 
  def __init__(self, success=None, ex=None,):
17430 
    self.success = success
17431 
    self.ex = ex
17432 
 
17433 
  def read(self, iprot):
17434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17436 
      return
17437 
    iprot.readStructBegin()
17438 
    while True:
17439 
      (fname, ftype, fid) = iprot.readFieldBegin()
17440 
      if ftype == TType.STOP:
17441 
        break
17442 
      if fid == 0:
17443 
        if ftype == TType.BOOL:
17444 
          self.success = iprot.readBool();
17445 
        else:
17446 
          iprot.skip(ftype)
17447 
      elif fid == 1:
17448 
        if ftype == TType.STRUCT:
17449 
          self.ex = TransactionServiceException()
17450 
          self.ex.read(iprot)
17451 
        else:
17452 
          iprot.skip(ftype)
17453 
      else:
17454 
        iprot.skip(ftype)
17455 
      iprot.readFieldEnd()
17456 
    iprot.readStructEnd()
17457 
 
17458 
  def write(self, oprot):
17459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17461 
      return
17462 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17463 
    if self.success is not None:
17464 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17465 
      oprot.writeBool(self.success)
17466 
      oprot.writeFieldEnd()
17467 
    if self.ex is not None:
17468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17469 
      self.ex.write(oprot)
17470 
      oprot.writeFieldEnd()
17471 
    oprot.writeFieldStop()
17472 
    oprot.writeStructEnd()
17473 
 
17474 
  def validate(self):
17475 
    return
17476 
 
17477 
 
17478 
  def __repr__(self):
17479 
    L = ['%s=%r' % (key, value)
17480 
      for key, value in self.__dict__.iteritems()]
17481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17482 
 
17483 
  def __eq__(self, other):
17484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17485 
 
17486 
  def __ne__(self, other):
17487 
    return not (self == other)
17488 
 
4386 anupam.sin 17489 
class getOrderForAwb_args:
17490 
  """
17491 
  Attributes:
17492 
   - awb
17493 
  """
17494 
 
17495 
  thrift_spec = (
17496 
    None, # 0
17497 
    (1, TType.STRING, 'awb', None, None, ), # 1
17498 
  )
17499 
 
17500 
  def __init__(self, awb=None,):
17501 
    self.awb = awb
17502 
 
17503 
  def read(self, iprot):
17504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17506 
      return
17507 
    iprot.readStructBegin()
17508 
    while True:
17509 
      (fname, ftype, fid) = iprot.readFieldBegin()
17510 
      if ftype == TType.STOP:
17511 
        break
17512 
      if fid == 1:
17513 
        if ftype == TType.STRING:
17514 
          self.awb = iprot.readString();
17515 
        else:
17516 
          iprot.skip(ftype)
17517 
      else:
17518 
        iprot.skip(ftype)
17519 
      iprot.readFieldEnd()
17520 
    iprot.readStructEnd()
17521 
 
17522 
  def write(self, oprot):
17523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17525 
      return
17526 
    oprot.writeStructBegin('getOrderForAwb_args')
17527 
    if self.awb is not None:
17528 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17529 
      oprot.writeString(self.awb)
17530 
      oprot.writeFieldEnd()
17531 
    oprot.writeFieldStop()
17532 
    oprot.writeStructEnd()
17533 
 
17534 
  def validate(self):
17535 
    return
17536 
 
17537 
 
17538 
  def __repr__(self):
17539 
    L = ['%s=%r' % (key, value)
17540 
      for key, value in self.__dict__.iteritems()]
17541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17542 
 
17543 
  def __eq__(self, other):
17544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17545 
 
17546 
  def __ne__(self, other):
17547 
    return not (self == other)
17548 
 
17549 
class getOrderForAwb_result:
17550 
  """
17551 
  Attributes:
17552 
   - success
17553 
   - ex
17554 
  """
17555 
 
17556 
  thrift_spec = (
17557 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17559 
  )
17560 
 
17561 
  def __init__(self, success=None, ex=None,):
17562 
    self.success = success
17563 
    self.ex = ex
17564 
 
17565 
  def read(self, iprot):
17566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17568 
      return
17569 
    iprot.readStructBegin()
17570 
    while True:
17571 
      (fname, ftype, fid) = iprot.readFieldBegin()
17572 
      if ftype == TType.STOP:
17573 
        break
17574 
      if fid == 0:
17575 
        if ftype == TType.STRUCT:
17576 
          self.success = Order()
17577 
          self.success.read(iprot)
17578 
        else:
17579 
          iprot.skip(ftype)
17580 
      elif fid == 1:
17581 
        if ftype == TType.STRUCT:
17582 
          self.ex = TransactionServiceException()
17583 
          self.ex.read(iprot)
17584 
        else:
17585 
          iprot.skip(ftype)
17586 
      else:
17587 
        iprot.skip(ftype)
17588 
      iprot.readFieldEnd()
17589 
    iprot.readStructEnd()
17590 
 
17591 
  def write(self, oprot):
17592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17594 
      return
17595 
    oprot.writeStructBegin('getOrderForAwb_result')
17596 
    if self.success is not None:
17597 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17598 
      self.success.write(oprot)
17599 
      oprot.writeFieldEnd()
17600 
    if self.ex is not None:
17601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17602 
      self.ex.write(oprot)
17603 
      oprot.writeFieldEnd()
17604 
    oprot.writeFieldStop()
17605 
    oprot.writeStructEnd()
17606 
 
17607 
  def validate(self):
17608 
    return
17609 
 
17610 
 
17611 
  def __repr__(self):
17612 
    L = ['%s=%r' % (key, value)
17613 
      for key, value in self.__dict__.iteritems()]
17614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17615 
 
17616 
  def __eq__(self, other):
17617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17618 
 
17619 
  def __ne__(self, other):
17620 
    return not (self == other)
4506 phani.kuma 17621 
 
17622 
class getOrdersForProviderForStatus_args:
17623 
  """
17624 
  Attributes:
17625 
   - logistics_provider_id
17626 
   - order_status
17627 
  """
17628 
 
17629 
  thrift_spec = (
17630 
    None, # 0
17631 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17632 
    (2, TType.I32, 'order_status', None, None, ), # 2
17633 
  )
17634 
 
17635 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17636 
    self.logistics_provider_id = logistics_provider_id
17637 
    self.order_status = order_status
17638 
 
17639 
  def read(self, iprot):
17640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17642 
      return
17643 
    iprot.readStructBegin()
17644 
    while True:
17645 
      (fname, ftype, fid) = iprot.readFieldBegin()
17646 
      if ftype == TType.STOP:
17647 
        break
17648 
      if fid == 1:
17649 
        if ftype == TType.I64:
17650 
          self.logistics_provider_id = iprot.readI64();
17651 
        else:
17652 
          iprot.skip(ftype)
17653 
      elif fid == 2:
17654 
        if ftype == TType.I32:
17655 
          self.order_status = iprot.readI32();
17656 
        else:
17657 
          iprot.skip(ftype)
17658 
      else:
17659 
        iprot.skip(ftype)
17660 
      iprot.readFieldEnd()
17661 
    iprot.readStructEnd()
17662 
 
17663 
  def write(self, oprot):
17664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17666 
      return
17667 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17668 
    if self.logistics_provider_id is not None:
17669 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17670 
      oprot.writeI64(self.logistics_provider_id)
17671 
      oprot.writeFieldEnd()
17672 
    if self.order_status is not None:
17673 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17674 
      oprot.writeI32(self.order_status)
17675 
      oprot.writeFieldEnd()
17676 
    oprot.writeFieldStop()
17677 
    oprot.writeStructEnd()
17678 
 
17679 
  def validate(self):
17680 
    return
17681 
 
17682 
 
17683 
  def __repr__(self):
17684 
    L = ['%s=%r' % (key, value)
17685 
      for key, value in self.__dict__.iteritems()]
17686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17687 
 
17688 
  def __eq__(self, other):
17689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17690 
 
17691 
  def __ne__(self, other):
17692 
    return not (self == other)
17693 
 
17694 
class getOrdersForProviderForStatus_result:
17695 
  """
17696 
  Attributes:
17697 
   - success
17698 
   - ex
17699 
  """
17700 
 
17701 
  thrift_spec = (
17702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17704 
  )
17705 
 
17706 
  def __init__(self, success=None, ex=None,):
17707 
    self.success = success
17708 
    self.ex = ex
17709 
 
17710 
  def read(self, iprot):
17711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17713 
      return
17714 
    iprot.readStructBegin()
17715 
    while True:
17716 
      (fname, ftype, fid) = iprot.readFieldBegin()
17717 
      if ftype == TType.STOP:
17718 
        break
17719 
      if fid == 0:
17720 
        if ftype == TType.LIST:
17721 
          self.success = []
4741 phani.kuma 17722 
          (_etype303, _size300) = iprot.readListBegin()
17723 
          for _i304 in xrange(_size300):
17724 
            _elem305 = Order()
17725 
            _elem305.read(iprot)
17726 
            self.success.append(_elem305)
4506 phani.kuma 17727 
          iprot.readListEnd()
17728 
        else:
17729 
          iprot.skip(ftype)
17730 
      elif fid == 1:
17731 
        if ftype == TType.STRUCT:
17732 
          self.ex = TransactionServiceException()
17733 
          self.ex.read(iprot)
17734 
        else:
17735 
          iprot.skip(ftype)
17736 
      else:
17737 
        iprot.skip(ftype)
17738 
      iprot.readFieldEnd()
17739 
    iprot.readStructEnd()
17740 
 
17741 
  def write(self, oprot):
17742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17744 
      return
17745 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17746 
    if self.success is not None:
17747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 17749 
      for iter306 in self.success:
17750 
        iter306.write(oprot)
4506 phani.kuma 17751 
      oprot.writeListEnd()
17752 
      oprot.writeFieldEnd()
17753 
    if self.ex is not None:
17754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17755 
      self.ex.write(oprot)
17756 
      oprot.writeFieldEnd()
17757 
    oprot.writeFieldStop()
17758 
    oprot.writeStructEnd()
17759 
 
17760 
  def validate(self):
17761 
    return
17762 
 
17763 
 
17764 
  def __repr__(self):
17765 
    L = ['%s=%r' % (key, value)
17766 
      for key, value in self.__dict__.iteritems()]
17767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17768 
 
17769 
  def __eq__(self, other):
17770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17771 
 
17772 
  def __ne__(self, other):
17773 
    return not (self == other)
4600 varun.gupt 17774 
 
17775 
class getBilledOrdersForVendor_args:
17776 
  """
17777 
  Attributes:
17778 
   - vendorId
17779 
   - billingDateFrom
17780 
   - billingDateTo
17781 
  """
17782 
 
17783 
  thrift_spec = (
17784 
    None, # 0
17785 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17786 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17787 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17788 
  )
17789 
 
17790 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17791 
    self.vendorId = vendorId
17792 
    self.billingDateFrom = billingDateFrom
17793 
    self.billingDateTo = billingDateTo
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      if fid == 1:
17805 
        if ftype == TType.I64:
17806 
          self.vendorId = iprot.readI64();
17807 
        else:
17808 
          iprot.skip(ftype)
17809 
      elif fid == 2:
17810 
        if ftype == TType.I64:
17811 
          self.billingDateFrom = iprot.readI64();
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      elif fid == 3:
17815 
        if ftype == TType.I64:
17816 
          self.billingDateTo = iprot.readI64();
17817 
        else:
17818 
          iprot.skip(ftype)
17819 
      else:
17820 
        iprot.skip(ftype)
17821 
      iprot.readFieldEnd()
17822 
    iprot.readStructEnd()
17823 
 
17824 
  def write(self, oprot):
17825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17827 
      return
17828 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17829 
    if self.vendorId is not None:
17830 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17831 
      oprot.writeI64(self.vendorId)
17832 
      oprot.writeFieldEnd()
17833 
    if self.billingDateFrom is not None:
17834 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17835 
      oprot.writeI64(self.billingDateFrom)
17836 
      oprot.writeFieldEnd()
17837 
    if self.billingDateTo is not None:
17838 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17839 
      oprot.writeI64(self.billingDateTo)
17840 
      oprot.writeFieldEnd()
17841 
    oprot.writeFieldStop()
17842 
    oprot.writeStructEnd()
17843 
 
17844 
  def validate(self):
17845 
    return
17846 
 
17847 
 
17848 
  def __repr__(self):
17849 
    L = ['%s=%r' % (key, value)
17850 
      for key, value in self.__dict__.iteritems()]
17851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17852 
 
17853 
  def __eq__(self, other):
17854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17855 
 
17856 
  def __ne__(self, other):
17857 
    return not (self == other)
17858 
 
17859 
class getBilledOrdersForVendor_result:
17860 
  """
17861 
  Attributes:
17862 
   - success
17863 
   - ex
17864 
  """
17865 
 
17866 
  thrift_spec = (
17867 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17869 
  )
17870 
 
17871 
  def __init__(self, success=None, ex=None,):
17872 
    self.success = success
17873 
    self.ex = ex
17874 
 
17875 
  def read(self, iprot):
17876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17878 
      return
17879 
    iprot.readStructBegin()
17880 
    while True:
17881 
      (fname, ftype, fid) = iprot.readFieldBegin()
17882 
      if ftype == TType.STOP:
17883 
        break
17884 
      if fid == 0:
17885 
        if ftype == TType.LIST:
17886 
          self.success = []
4741 phani.kuma 17887 
          (_etype310, _size307) = iprot.readListBegin()
17888 
          for _i311 in xrange(_size307):
17889 
            _elem312 = Order()
17890 
            _elem312.read(iprot)
17891 
            self.success.append(_elem312)
4600 varun.gupt 17892 
          iprot.readListEnd()
17893 
        else:
17894 
          iprot.skip(ftype)
17895 
      elif fid == 1:
17896 
        if ftype == TType.STRUCT:
17897 
          self.ex = TransactionServiceException()
17898 
          self.ex.read(iprot)
17899 
        else:
17900 
          iprot.skip(ftype)
17901 
      else:
17902 
        iprot.skip(ftype)
17903 
      iprot.readFieldEnd()
17904 
    iprot.readStructEnd()
17905 
 
17906 
  def write(self, oprot):
17907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17909 
      return
17910 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17911 
    if self.success is not None:
17912 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17913 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 17914 
      for iter313 in self.success:
17915 
        iter313.write(oprot)
4600 varun.gupt 17916 
      oprot.writeListEnd()
17917 
      oprot.writeFieldEnd()
17918 
    if self.ex is not None:
17919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17920 
      self.ex.write(oprot)
17921 
      oprot.writeFieldEnd()
17922 
    oprot.writeFieldStop()
17923 
    oprot.writeStructEnd()
17924 
 
17925 
  def validate(self):
17926 
    return
17927 
 
17928 
 
17929 
  def __repr__(self):
17930 
    L = ['%s=%r' % (key, value)
17931 
      for key, value in self.__dict__.iteritems()]
17932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17933 
 
17934 
  def __eq__(self, other):
17935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17936 
 
17937 
  def __ne__(self, other):
17938 
    return not (self == other)
17939 
 
4607 rajveer 17940 
class getSlippedSippingDateOrders_args:
17941 
 
17942 
  thrift_spec = (
17943 
  )
17944 
 
17945 
  def read(self, iprot):
17946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17948 
      return
17949 
    iprot.readStructBegin()
17950 
    while True:
17951 
      (fname, ftype, fid) = iprot.readFieldBegin()
17952 
      if ftype == TType.STOP:
17953 
        break
17954 
      else:
17955 
        iprot.skip(ftype)
17956 
      iprot.readFieldEnd()
17957 
    iprot.readStructEnd()
17958 
 
17959 
  def write(self, oprot):
17960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17962 
      return
17963 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17964 
    oprot.writeFieldStop()
17965 
    oprot.writeStructEnd()
17966 
 
17967 
  def validate(self):
17968 
    return
17969 
 
17970 
 
17971 
  def __repr__(self):
17972 
    L = ['%s=%r' % (key, value)
17973 
      for key, value in self.__dict__.iteritems()]
17974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17975 
 
17976 
  def __eq__(self, other):
17977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17978 
 
17979 
  def __ne__(self, other):
17980 
    return not (self == other)
17981 
 
17982 
class getSlippedSippingDateOrders_result:
17983 
  """
17984 
  Attributes:
17985 
   - success
17986 
   - ex
17987 
  """
17988 
 
17989 
  thrift_spec = (
17990 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17992 
  )
17993 
 
17994 
  def __init__(self, success=None, ex=None,):
17995 
    self.success = success
17996 
    self.ex = ex
17997 
 
17998 
  def read(self, iprot):
17999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18001 
      return
18002 
    iprot.readStructBegin()
18003 
    while True:
18004 
      (fname, ftype, fid) = iprot.readFieldBegin()
18005 
      if ftype == TType.STOP:
18006 
        break
18007 
      if fid == 0:
18008 
        if ftype == TType.LIST:
18009 
          self.success = []
4741 phani.kuma 18010 
          (_etype317, _size314) = iprot.readListBegin()
18011 
          for _i318 in xrange(_size314):
18012 
            _elem319 = Order()
18013 
            _elem319.read(iprot)
18014 
            self.success.append(_elem319)
4607 rajveer 18015 
          iprot.readListEnd()
18016 
        else:
18017 
          iprot.skip(ftype)
18018 
      elif fid == 1:
18019 
        if ftype == TType.STRUCT:
18020 
          self.ex = TransactionServiceException()
18021 
          self.ex.read(iprot)
18022 
        else:
18023 
          iprot.skip(ftype)
18024 
      else:
18025 
        iprot.skip(ftype)
18026 
      iprot.readFieldEnd()
18027 
    iprot.readStructEnd()
18028 
 
18029 
  def write(self, oprot):
18030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18032 
      return
18033 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
18034 
    if self.success is not None:
18035 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18036 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 18037 
      for iter320 in self.success:
18038 
        iter320.write(oprot)
4607 rajveer 18039 
      oprot.writeListEnd()
18040 
      oprot.writeFieldEnd()
18041 
    if self.ex is not None:
18042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18043 
      self.ex.write(oprot)
18044 
      oprot.writeFieldEnd()
18045 
    oprot.writeFieldStop()
18046 
    oprot.writeStructEnd()
18047 
 
18048 
  def validate(self):
18049 
    return
18050 
 
18051 
 
18052 
  def __repr__(self):
18053 
    L = ['%s=%r' % (key, value)
18054 
      for key, value in self.__dict__.iteritems()]
18055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18056 
 
18057 
  def __eq__(self, other):
18058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18059 
 
18060 
  def __ne__(self, other):
18061 
    return not (self == other)
18062 
 
4709 rajveer 18063 
class getCancelledOrders_args:
18064 
  """
18065 
  Attributes:
18066 
   - cancelDateFrom
18067 
   - cancelDateTo
18068 
  """
18069 
 
18070 
  thrift_spec = (
18071 
    None, # 0
18072 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
18073 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
18074 
  )
18075 
 
18076 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
18077 
    self.cancelDateFrom = cancelDateFrom
18078 
    self.cancelDateTo = cancelDateTo
18079 
 
18080 
  def read(self, iprot):
18081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18083 
      return
18084 
    iprot.readStructBegin()
18085 
    while True:
18086 
      (fname, ftype, fid) = iprot.readFieldBegin()
18087 
      if ftype == TType.STOP:
18088 
        break
18089 
      if fid == 1:
18090 
        if ftype == TType.I64:
18091 
          self.cancelDateFrom = iprot.readI64();
18092 
        else:
18093 
          iprot.skip(ftype)
18094 
      elif fid == 2:
18095 
        if ftype == TType.I64:
18096 
          self.cancelDateTo = iprot.readI64();
18097 
        else:
18098 
          iprot.skip(ftype)
18099 
      else:
18100 
        iprot.skip(ftype)
18101 
      iprot.readFieldEnd()
18102 
    iprot.readStructEnd()
18103 
 
18104 
  def write(self, oprot):
18105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18107 
      return
18108 
    oprot.writeStructBegin('getCancelledOrders_args')
18109 
    if self.cancelDateFrom is not None:
18110 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18111 
      oprot.writeI64(self.cancelDateFrom)
18112 
      oprot.writeFieldEnd()
18113 
    if self.cancelDateTo is not None:
18114 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18115 
      oprot.writeI64(self.cancelDateTo)
18116 
      oprot.writeFieldEnd()
18117 
    oprot.writeFieldStop()
18118 
    oprot.writeStructEnd()
18119 
 
18120 
  def validate(self):
18121 
    return
18122 
 
18123 
 
18124 
  def __repr__(self):
18125 
    L = ['%s=%r' % (key, value)
18126 
      for key, value in self.__dict__.iteritems()]
18127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18128 
 
18129 
  def __eq__(self, other):
18130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18131 
 
18132 
  def __ne__(self, other):
18133 
    return not (self == other)
18134 
 
18135 
class getCancelledOrders_result:
18136 
  """
18137 
  Attributes:
18138 
   - success
18139 
   - ex
18140 
  """
18141 
 
18142 
  thrift_spec = (
18143 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18144 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18145 
  )
18146 
 
18147 
  def __init__(self, success=None, ex=None,):
18148 
    self.success = success
18149 
    self.ex = ex
18150 
 
18151 
  def read(self, iprot):
18152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18154 
      return
18155 
    iprot.readStructBegin()
18156 
    while True:
18157 
      (fname, ftype, fid) = iprot.readFieldBegin()
18158 
      if ftype == TType.STOP:
18159 
        break
18160 
      if fid == 0:
18161 
        if ftype == TType.LIST:
18162 
          self.success = []
4741 phani.kuma 18163 
          (_etype324, _size321) = iprot.readListBegin()
18164 
          for _i325 in xrange(_size321):
18165 
            _elem326 = Order()
18166 
            _elem326.read(iprot)
18167 
            self.success.append(_elem326)
4709 rajveer 18168 
          iprot.readListEnd()
18169 
        else:
18170 
          iprot.skip(ftype)
18171 
      elif fid == 1:
18172 
        if ftype == TType.STRUCT:
18173 
          self.ex = TransactionServiceException()
18174 
          self.ex.read(iprot)
18175 
        else:
18176 
          iprot.skip(ftype)
18177 
      else:
18178 
        iprot.skip(ftype)
18179 
      iprot.readFieldEnd()
18180 
    iprot.readStructEnd()
18181 
 
18182 
  def write(self, oprot):
18183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18185 
      return
18186 
    oprot.writeStructBegin('getCancelledOrders_result')
18187 
    if self.success is not None:
18188 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18189 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 18190 
      for iter327 in self.success:
18191 
        iter327.write(oprot)
4709 rajveer 18192 
      oprot.writeListEnd()
18193 
      oprot.writeFieldEnd()
18194 
    if self.ex is not None:
18195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18196 
      self.ex.write(oprot)
18197 
      oprot.writeFieldEnd()
18198 
    oprot.writeFieldStop()
18199 
    oprot.writeStructEnd()
18200 
 
18201 
  def validate(self):
18202 
    return
18203 
 
18204 
 
18205 
  def __repr__(self):
18206 
    L = ['%s=%r' % (key, value)
18207 
      for key, value in self.__dict__.iteritems()]
18208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18209 
 
18210 
  def __eq__(self, other):
18211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18212 
 
18213 
  def __ne__(self, other):
18214 
    return not (self == other)
18215 
 
4600 varun.gupt 18216 
class saveBluedartSettlements_args:
18217 
  """
18218 
  Attributes:
18219 
   - mapAWBAndAmount
18220 
  """
18221 
 
18222 
  thrift_spec = (
18223 
    None, # 0
18224 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18225 
  )
18226 
 
18227 
  def __init__(self, mapAWBAndAmount=None,):
18228 
    self.mapAWBAndAmount = mapAWBAndAmount
18229 
 
18230 
  def read(self, iprot):
18231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18233 
      return
18234 
    iprot.readStructBegin()
18235 
    while True:
18236 
      (fname, ftype, fid) = iprot.readFieldBegin()
18237 
      if ftype == TType.STOP:
18238 
        break
18239 
      if fid == 1:
18240 
        if ftype == TType.MAP:
18241 
          self.mapAWBAndAmount = {}
4741 phani.kuma 18242 
          (_ktype329, _vtype330, _size328 ) = iprot.readMapBegin()
18243 
          for _i332 in xrange(_size328):
18244 
            _key333 = iprot.readI64();
18245 
            _val334 = iprot.readDouble();
18246 
            self.mapAWBAndAmount[_key333] = _val334
4600 varun.gupt 18247 
          iprot.readMapEnd()
18248 
        else:
18249 
          iprot.skip(ftype)
18250 
      else:
18251 
        iprot.skip(ftype)
18252 
      iprot.readFieldEnd()
18253 
    iprot.readStructEnd()
18254 
 
18255 
  def write(self, oprot):
18256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18258 
      return
18259 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18260 
    if self.mapAWBAndAmount is not None:
18261 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18262 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4741 phani.kuma 18263 
      for kiter335,viter336 in self.mapAWBAndAmount.items():
18264 
        oprot.writeI64(kiter335)
18265 
        oprot.writeDouble(viter336)
4600 varun.gupt 18266 
      oprot.writeMapEnd()
18267 
      oprot.writeFieldEnd()
18268 
    oprot.writeFieldStop()
18269 
    oprot.writeStructEnd()
18270 
 
18271 
  def validate(self):
18272 
    return
18273 
 
18274 
 
18275 
  def __repr__(self):
18276 
    L = ['%s=%r' % (key, value)
18277 
      for key, value in self.__dict__.iteritems()]
18278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18279 
 
18280 
  def __eq__(self, other):
18281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18282 
 
18283 
  def __ne__(self, other):
18284 
    return not (self == other)
18285 
 
18286 
class saveBluedartSettlements_result:
18287 
  """
18288 
  Attributes:
18289 
   - ex
18290 
  """
18291 
 
18292 
  thrift_spec = (
18293 
    None, # 0
18294 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18295 
  )
18296 
 
18297 
  def __init__(self, ex=None,):
18298 
    self.ex = ex
18299 
 
18300 
  def read(self, iprot):
18301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18303 
      return
18304 
    iprot.readStructBegin()
18305 
    while True:
18306 
      (fname, ftype, fid) = iprot.readFieldBegin()
18307 
      if ftype == TType.STOP:
18308 
        break
18309 
      if fid == 1:
18310 
        if ftype == TType.STRUCT:
18311 
          self.ex = TransactionServiceException()
18312 
          self.ex.read(iprot)
18313 
        else:
18314 
          iprot.skip(ftype)
18315 
      else:
18316 
        iprot.skip(ftype)
18317 
      iprot.readFieldEnd()
18318 
    iprot.readStructEnd()
18319 
 
18320 
  def write(self, oprot):
18321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18323 
      return
18324 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18325 
    if self.ex is not None:
18326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18327 
      self.ex.write(oprot)
18328 
      oprot.writeFieldEnd()
18329 
    oprot.writeFieldStop()
18330 
    oprot.writeStructEnd()
18331 
 
18332 
  def validate(self):
18333 
    return
18334 
 
18335 
 
18336 
  def __repr__(self):
18337 
    L = ['%s=%r' % (key, value)
18338 
      for key, value in self.__dict__.iteritems()]
18339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18340 
 
18341 
  def __eq__(self, other):
18342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18343 
 
18344 
  def __ne__(self, other):
18345 
    return not (self == other)
18346 
 
18347 
class savePaymentSettlements_args:
18348 
  """
18349 
  Attributes:
18350 
   - settlementDate
18351 
   - paymentGatewayId
18352 
   - paymentId
18353 
   - serviceTax
18354 
   - otherCharges
18355 
   - netCollection
18356 
  """
18357 
 
18358 
  thrift_spec = (
18359 
    None, # 0
18360 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18361 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18362 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18363 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18364 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18365 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18366 
  )
18367 
 
18368 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18369 
    self.settlementDate = settlementDate
18370 
    self.paymentGatewayId = paymentGatewayId
18371 
    self.paymentId = paymentId
18372 
    self.serviceTax = serviceTax
18373 
    self.otherCharges = otherCharges
18374 
    self.netCollection = netCollection
18375 
 
18376 
  def read(self, iprot):
18377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18379 
      return
18380 
    iprot.readStructBegin()
18381 
    while True:
18382 
      (fname, ftype, fid) = iprot.readFieldBegin()
18383 
      if ftype == TType.STOP:
18384 
        break
18385 
      if fid == 1:
18386 
        if ftype == TType.I64:
18387 
          self.settlementDate = iprot.readI64();
18388 
        else:
18389 
          iprot.skip(ftype)
18390 
      elif fid == 2:
18391 
        if ftype == TType.I64:
18392 
          self.paymentGatewayId = iprot.readI64();
18393 
        else:
18394 
          iprot.skip(ftype)
18395 
      elif fid == 3:
18396 
        if ftype == TType.I64:
18397 
          self.paymentId = iprot.readI64();
18398 
        else:
18399 
          iprot.skip(ftype)
18400 
      elif fid == 4:
18401 
        if ftype == TType.DOUBLE:
18402 
          self.serviceTax = iprot.readDouble();
18403 
        else:
18404 
          iprot.skip(ftype)
18405 
      elif fid == 5:
18406 
        if ftype == TType.DOUBLE:
18407 
          self.otherCharges = iprot.readDouble();
18408 
        else:
18409 
          iprot.skip(ftype)
18410 
      elif fid == 6:
18411 
        if ftype == TType.DOUBLE:
18412 
          self.netCollection = iprot.readDouble();
18413 
        else:
18414 
          iprot.skip(ftype)
18415 
      else:
18416 
        iprot.skip(ftype)
18417 
      iprot.readFieldEnd()
18418 
    iprot.readStructEnd()
18419 
 
18420 
  def write(self, oprot):
18421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18423 
      return
18424 
    oprot.writeStructBegin('savePaymentSettlements_args')
18425 
    if self.settlementDate is not None:
18426 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18427 
      oprot.writeI64(self.settlementDate)
18428 
      oprot.writeFieldEnd()
18429 
    if self.paymentGatewayId is not None:
18430 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18431 
      oprot.writeI64(self.paymentGatewayId)
18432 
      oprot.writeFieldEnd()
18433 
    if self.paymentId is not None:
18434 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18435 
      oprot.writeI64(self.paymentId)
18436 
      oprot.writeFieldEnd()
18437 
    if self.serviceTax is not None:
18438 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18439 
      oprot.writeDouble(self.serviceTax)
18440 
      oprot.writeFieldEnd()
18441 
    if self.otherCharges is not None:
18442 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18443 
      oprot.writeDouble(self.otherCharges)
18444 
      oprot.writeFieldEnd()
18445 
    if self.netCollection is not None:
18446 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18447 
      oprot.writeDouble(self.netCollection)
18448 
      oprot.writeFieldEnd()
18449 
    oprot.writeFieldStop()
18450 
    oprot.writeStructEnd()
18451 
 
18452 
  def validate(self):
18453 
    return
18454 
 
18455 
 
18456 
  def __repr__(self):
18457 
    L = ['%s=%r' % (key, value)
18458 
      for key, value in self.__dict__.iteritems()]
18459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18460 
 
18461 
  def __eq__(self, other):
18462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18463 
 
18464 
  def __ne__(self, other):
18465 
    return not (self == other)
18466 
 
18467 
class savePaymentSettlements_result:
18468 
  """
18469 
  Attributes:
18470 
   - ex
18471 
  """
18472 
 
18473 
  thrift_spec = (
18474 
    None, # 0
18475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18476 
  )
18477 
 
18478 
  def __init__(self, ex=None,):
18479 
    self.ex = ex
18480 
 
18481 
  def read(self, iprot):
18482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18484 
      return
18485 
    iprot.readStructBegin()
18486 
    while True:
18487 
      (fname, ftype, fid) = iprot.readFieldBegin()
18488 
      if ftype == TType.STOP:
18489 
        break
18490 
      if fid == 1:
18491 
        if ftype == TType.STRUCT:
18492 
          self.ex = TransactionServiceException()
18493 
          self.ex.read(iprot)
18494 
        else:
18495 
          iprot.skip(ftype)
18496 
      else:
18497 
        iprot.skip(ftype)
18498 
      iprot.readFieldEnd()
18499 
    iprot.readStructEnd()
18500 
 
18501 
  def write(self, oprot):
18502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18504 
      return
18505 
    oprot.writeStructBegin('savePaymentSettlements_result')
18506 
    if self.ex is not None:
18507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18508 
      self.ex.write(oprot)
18509 
      oprot.writeFieldEnd()
18510 
    oprot.writeFieldStop()
18511 
    oprot.writeStructEnd()
18512 
 
18513 
  def validate(self):
18514 
    return
18515 
 
18516 
 
18517 
  def __repr__(self):
18518 
    L = ['%s=%r' % (key, value)
18519 
      for key, value in self.__dict__.iteritems()]
18520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18521 
 
18522 
  def __eq__(self, other):
18523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18524 
 
18525 
  def __ne__(self, other):
18526 
    return not (self == other)
18527 
 
18528 
class saveEBSSettlementSummary_args:
18529 
  """
18530 
  Attributes:
18531 
   - settlementId
18532 
   - settlementDate
18533 
   - transactionDateFrom
18534 
   - transactionDateTo
18535 
   - amount
18536 
  """
18537 
 
18538 
  thrift_spec = (
18539 
    None, # 0
18540 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18541 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18542 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18543 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18544 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18545 
  )
18546 
 
18547 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18548 
    self.settlementId = settlementId
18549 
    self.settlementDate = settlementDate
18550 
    self.transactionDateFrom = transactionDateFrom
18551 
    self.transactionDateTo = transactionDateTo
18552 
    self.amount = amount
18553 
 
18554 
  def read(self, iprot):
18555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18557 
      return
18558 
    iprot.readStructBegin()
18559 
    while True:
18560 
      (fname, ftype, fid) = iprot.readFieldBegin()
18561 
      if ftype == TType.STOP:
18562 
        break
18563 
      if fid == 1:
18564 
        if ftype == TType.I64:
18565 
          self.settlementId = iprot.readI64();
18566 
        else:
18567 
          iprot.skip(ftype)
18568 
      elif fid == 2:
18569 
        if ftype == TType.I64:
18570 
          self.settlementDate = iprot.readI64();
18571 
        else:
18572 
          iprot.skip(ftype)
18573 
      elif fid == 3:
18574 
        if ftype == TType.I64:
18575 
          self.transactionDateFrom = iprot.readI64();
18576 
        else:
18577 
          iprot.skip(ftype)
18578 
      elif fid == 4:
18579 
        if ftype == TType.I64:
18580 
          self.transactionDateTo = iprot.readI64();
18581 
        else:
18582 
          iprot.skip(ftype)
18583 
      elif fid == 5:
18584 
        if ftype == TType.DOUBLE:
18585 
          self.amount = iprot.readDouble();
18586 
        else:
18587 
          iprot.skip(ftype)
18588 
      else:
18589 
        iprot.skip(ftype)
18590 
      iprot.readFieldEnd()
18591 
    iprot.readStructEnd()
18592 
 
18593 
  def write(self, oprot):
18594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18596 
      return
18597 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18598 
    if self.settlementId is not None:
18599 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18600 
      oprot.writeI64(self.settlementId)
18601 
      oprot.writeFieldEnd()
18602 
    if self.settlementDate is not None:
18603 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18604 
      oprot.writeI64(self.settlementDate)
18605 
      oprot.writeFieldEnd()
18606 
    if self.transactionDateFrom is not None:
18607 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18608 
      oprot.writeI64(self.transactionDateFrom)
18609 
      oprot.writeFieldEnd()
18610 
    if self.transactionDateTo is not None:
18611 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18612 
      oprot.writeI64(self.transactionDateTo)
18613 
      oprot.writeFieldEnd()
18614 
    if self.amount is not None:
18615 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18616 
      oprot.writeDouble(self.amount)
18617 
      oprot.writeFieldEnd()
18618 
    oprot.writeFieldStop()
18619 
    oprot.writeStructEnd()
18620 
 
18621 
  def validate(self):
18622 
    return
18623 
 
18624 
 
18625 
  def __repr__(self):
18626 
    L = ['%s=%r' % (key, value)
18627 
      for key, value in self.__dict__.iteritems()]
18628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18629 
 
18630 
  def __eq__(self, other):
18631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18632 
 
18633 
  def __ne__(self, other):
18634 
    return not (self == other)
18635 
 
18636 
class saveEBSSettlementSummary_result:
18637 
  """
18638 
  Attributes:
18639 
   - ex
18640 
  """
18641 
 
18642 
  thrift_spec = (
18643 
    None, # 0
18644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18645 
  )
18646 
 
18647 
  def __init__(self, ex=None,):
18648 
    self.ex = ex
18649 
 
18650 
  def read(self, iprot):
18651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18653 
      return
18654 
    iprot.readStructBegin()
18655 
    while True:
18656 
      (fname, ftype, fid) = iprot.readFieldBegin()
18657 
      if ftype == TType.STOP:
18658 
        break
18659 
      if fid == 1:
18660 
        if ftype == TType.STRUCT:
18661 
          self.ex = TransactionServiceException()
18662 
          self.ex.read(iprot)
18663 
        else:
18664 
          iprot.skip(ftype)
18665 
      else:
18666 
        iprot.skip(ftype)
18667 
      iprot.readFieldEnd()
18668 
    iprot.readStructEnd()
18669 
 
18670 
  def write(self, oprot):
18671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18673 
      return
18674 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18675 
    if self.ex is not None:
18676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18677 
      self.ex.write(oprot)
18678 
      oprot.writeFieldEnd()
18679 
    oprot.writeFieldStop()
18680 
    oprot.writeStructEnd()
18681 
 
18682 
  def validate(self):
18683 
    return
18684 
 
18685 
 
18686 
  def __repr__(self):
18687 
    L = ['%s=%r' % (key, value)
18688 
      for key, value in self.__dict__.iteritems()]
18689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18690 
 
18691 
  def __eq__(self, other):
18692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18693 
 
18694 
  def __ne__(self, other):
18695 
    return not (self == other)
18696 
 
18697 
class getSettlementForPaymentId_args:
18698 
  """
18699 
  Attributes:
18700 
   - paymentId
18701 
  """
18702 
 
18703 
  thrift_spec = (
18704 
    None, # 0
18705 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18706 
  )
18707 
 
18708 
  def __init__(self, paymentId=None,):
18709 
    self.paymentId = paymentId
18710 
 
18711 
  def read(self, iprot):
18712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18714 
      return
18715 
    iprot.readStructBegin()
18716 
    while True:
18717 
      (fname, ftype, fid) = iprot.readFieldBegin()
18718 
      if ftype == TType.STOP:
18719 
        break
18720 
      if fid == 1:
18721 
        if ftype == TType.I64:
18722 
          self.paymentId = iprot.readI64();
18723 
        else:
18724 
          iprot.skip(ftype)
18725 
      else:
18726 
        iprot.skip(ftype)
18727 
      iprot.readFieldEnd()
18728 
    iprot.readStructEnd()
18729 
 
18730 
  def write(self, oprot):
18731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18733 
      return
18734 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18735 
    if self.paymentId is not None:
18736 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18737 
      oprot.writeI64(self.paymentId)
18738 
      oprot.writeFieldEnd()
18739 
    oprot.writeFieldStop()
18740 
    oprot.writeStructEnd()
18741 
 
18742 
  def validate(self):
18743 
    return
18744 
 
18745 
 
18746 
  def __repr__(self):
18747 
    L = ['%s=%r' % (key, value)
18748 
      for key, value in self.__dict__.iteritems()]
18749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18750 
 
18751 
  def __eq__(self, other):
18752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18753 
 
18754 
  def __ne__(self, other):
18755 
    return not (self == other)
18756 
 
18757 
class getSettlementForPaymentId_result:
18758 
  """
18759 
  Attributes:
18760 
   - success
18761 
   - ex
18762 
  """
18763 
 
18764 
  thrift_spec = (
18765 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18767 
  )
18768 
 
18769 
  def __init__(self, success=None, ex=None,):
18770 
    self.success = success
18771 
    self.ex = ex
18772 
 
18773 
  def read(self, iprot):
18774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18776 
      return
18777 
    iprot.readStructBegin()
18778 
    while True:
18779 
      (fname, ftype, fid) = iprot.readFieldBegin()
18780 
      if ftype == TType.STOP:
18781 
        break
18782 
      if fid == 0:
18783 
        if ftype == TType.STRUCT:
18784 
          self.success = PaymentSettlement()
18785 
          self.success.read(iprot)
18786 
        else:
18787 
          iprot.skip(ftype)
18788 
      elif fid == 1:
18789 
        if ftype == TType.STRUCT:
18790 
          self.ex = TransactionServiceException()
18791 
          self.ex.read(iprot)
18792 
        else:
18793 
          iprot.skip(ftype)
18794 
      else:
18795 
        iprot.skip(ftype)
18796 
      iprot.readFieldEnd()
18797 
    iprot.readStructEnd()
18798 
 
18799 
  def write(self, oprot):
18800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18802 
      return
18803 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18804 
    if self.success is not None:
18805 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18806 
      self.success.write(oprot)
18807 
      oprot.writeFieldEnd()
18808 
    if self.ex is not None:
18809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18810 
      self.ex.write(oprot)
18811 
      oprot.writeFieldEnd()
18812 
    oprot.writeFieldStop()
18813 
    oprot.writeStructEnd()
18814 
 
18815 
  def validate(self):
18816 
    return
18817 
 
18818 
 
18819 
  def __repr__(self):
18820 
    L = ['%s=%r' % (key, value)
18821 
      for key, value in self.__dict__.iteritems()]
18822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18823 
 
18824 
  def __eq__(self, other):
18825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18826 
 
18827 
  def __ne__(self, other):
18828 
    return not (self == other)
18829 
 
18830 
class getEBSSettlementSummaries_args:
18831 
 
18832 
  thrift_spec = (
18833 
  )
18834 
 
18835 
  def read(self, iprot):
18836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18838 
      return
18839 
    iprot.readStructBegin()
18840 
    while True:
18841 
      (fname, ftype, fid) = iprot.readFieldBegin()
18842 
      if ftype == TType.STOP:
18843 
        break
18844 
      else:
18845 
        iprot.skip(ftype)
18846 
      iprot.readFieldEnd()
18847 
    iprot.readStructEnd()
18848 
 
18849 
  def write(self, oprot):
18850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18852 
      return
18853 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18854 
    oprot.writeFieldStop()
18855 
    oprot.writeStructEnd()
18856 
 
18857 
  def validate(self):
18858 
    return
18859 
 
18860 
 
18861 
  def __repr__(self):
18862 
    L = ['%s=%r' % (key, value)
18863 
      for key, value in self.__dict__.iteritems()]
18864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18865 
 
18866 
  def __eq__(self, other):
18867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18868 
 
18869 
  def __ne__(self, other):
18870 
    return not (self == other)
18871 
 
18872 
class getEBSSettlementSummaries_result:
18873 
  """
18874 
  Attributes:
18875 
   - success
18876 
   - ex
18877 
  """
18878 
 
18879 
  thrift_spec = (
18880 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18882 
  )
18883 
 
18884 
  def __init__(self, success=None, ex=None,):
18885 
    self.success = success
18886 
    self.ex = ex
18887 
 
18888 
  def read(self, iprot):
18889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18891 
      return
18892 
    iprot.readStructBegin()
18893 
    while True:
18894 
      (fname, ftype, fid) = iprot.readFieldBegin()
18895 
      if ftype == TType.STOP:
18896 
        break
18897 
      if fid == 0:
18898 
        if ftype == TType.MAP:
18899 
          self.success = {}
4741 phani.kuma 18900 
          (_ktype338, _vtype339, _size337 ) = iprot.readMapBegin()
18901 
          for _i341 in xrange(_size337):
18902 
            _key342 = iprot.readI64();
18903 
            _val343 = iprot.readString();
18904 
            self.success[_key342] = _val343
4600 varun.gupt 18905 
          iprot.readMapEnd()
18906 
        else:
18907 
          iprot.skip(ftype)
18908 
      elif fid == 1:
18909 
        if ftype == TType.STRUCT:
18910 
          self.ex = TransactionServiceException()
18911 
          self.ex.read(iprot)
18912 
        else:
18913 
          iprot.skip(ftype)
18914 
      else:
18915 
        iprot.skip(ftype)
18916 
      iprot.readFieldEnd()
18917 
    iprot.readStructEnd()
18918 
 
18919 
  def write(self, oprot):
18920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18922 
      return
18923 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18924 
    if self.success is not None:
18925 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18926 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4741 phani.kuma 18927 
      for kiter344,viter345 in self.success.items():
18928 
        oprot.writeI64(kiter344)
18929 
        oprot.writeString(viter345)
4600 varun.gupt 18930 
      oprot.writeMapEnd()
18931 
      oprot.writeFieldEnd()
18932 
    if self.ex is not None:
18933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18934 
      self.ex.write(oprot)
18935 
      oprot.writeFieldEnd()
18936 
    oprot.writeFieldStop()
18937 
    oprot.writeStructEnd()
18938 
 
18939 
  def validate(self):
18940 
    return
18941 
 
18942 
 
18943 
  def __repr__(self):
18944 
    L = ['%s=%r' % (key, value)
18945 
      for key, value in self.__dict__.iteritems()]
18946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18947 
 
18948 
  def __eq__(self, other):
18949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18950 
 
18951 
  def __ne__(self, other):
18952 
    return not (self == other)
18953 
 
18954 
class markEBSSettlementUploaded_args:
18955 
  """
18956 
  Attributes:
18957 
   - settlementId
18958 
  """
18959 
 
18960 
  thrift_spec = (
18961 
    None, # 0
18962 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18963 
  )
18964 
 
18965 
  def __init__(self, settlementId=None,):
18966 
    self.settlementId = settlementId
18967 
 
18968 
  def read(self, iprot):
18969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18971 
      return
18972 
    iprot.readStructBegin()
18973 
    while True:
18974 
      (fname, ftype, fid) = iprot.readFieldBegin()
18975 
      if ftype == TType.STOP:
18976 
        break
18977 
      if fid == 1:
18978 
        if ftype == TType.I64:
18979 
          self.settlementId = iprot.readI64();
18980 
        else:
18981 
          iprot.skip(ftype)
18982 
      else:
18983 
        iprot.skip(ftype)
18984 
      iprot.readFieldEnd()
18985 
    iprot.readStructEnd()
18986 
 
18987 
  def write(self, oprot):
18988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18990 
      return
18991 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18992 
    if self.settlementId is not None:
18993 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18994 
      oprot.writeI64(self.settlementId)
18995 
      oprot.writeFieldEnd()
18996 
    oprot.writeFieldStop()
18997 
    oprot.writeStructEnd()
18998 
 
18999 
  def validate(self):
19000 
    return
19001 
 
19002 
 
19003 
  def __repr__(self):
19004 
    L = ['%s=%r' % (key, value)
19005 
      for key, value in self.__dict__.iteritems()]
19006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19007 
 
19008 
  def __eq__(self, other):
19009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19010 
 
19011 
  def __ne__(self, other):
19012 
    return not (self == other)
19013 
 
19014 
class markEBSSettlementUploaded_result:
19015 
  """
19016 
  Attributes:
19017 
   - ex
19018 
  """
19019 
 
19020 
  thrift_spec = (
19021 
    None, # 0
19022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19023 
  )
19024 
 
19025 
  def __init__(self, ex=None,):
19026 
    self.ex = ex
19027 
 
19028 
  def read(self, iprot):
19029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19031 
      return
19032 
    iprot.readStructBegin()
19033 
    while True:
19034 
      (fname, ftype, fid) = iprot.readFieldBegin()
19035 
      if ftype == TType.STOP:
19036 
        break
19037 
      if fid == 1:
19038 
        if ftype == TType.STRUCT:
19039 
          self.ex = TransactionServiceException()
19040 
          self.ex.read(iprot)
19041 
        else:
19042 
          iprot.skip(ftype)
19043 
      else:
19044 
        iprot.skip(ftype)
19045 
      iprot.readFieldEnd()
19046 
    iprot.readStructEnd()
19047 
 
19048 
  def write(self, oprot):
19049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19051 
      return
19052 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
19053 
    if self.ex is not None:
19054 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19055 
      self.ex.write(oprot)
19056 
      oprot.writeFieldEnd()
19057 
    oprot.writeFieldStop()
19058 
    oprot.writeStructEnd()
19059 
 
19060 
  def validate(self):
19061 
    return
19062 
 
19063 
 
19064 
  def __repr__(self):
19065 
    L = ['%s=%r' % (key, value)
19066 
      for key, value in self.__dict__.iteritems()]
19067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19068 
 
19069 
  def __eq__(self, other):
19070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19071 
 
19072 
  def __ne__(self, other):
19073 
    return not (self == other)
19074 
 
19075 
class getEBSSettlementDate_args:
19076 
  """
19077 
  Attributes:
19078 
   - settlementId
19079 
  """
19080 
 
19081 
  thrift_spec = (
19082 
    None, # 0
19083 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19084 
  )
19085 
 
19086 
  def __init__(self, settlementId=None,):
19087 
    self.settlementId = settlementId
19088 
 
19089 
  def read(self, iprot):
19090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19092 
      return
19093 
    iprot.readStructBegin()
19094 
    while True:
19095 
      (fname, ftype, fid) = iprot.readFieldBegin()
19096 
      if ftype == TType.STOP:
19097 
        break
19098 
      if fid == 1:
19099 
        if ftype == TType.I64:
19100 
          self.settlementId = iprot.readI64();
19101 
        else:
19102 
          iprot.skip(ftype)
19103 
      else:
19104 
        iprot.skip(ftype)
19105 
      iprot.readFieldEnd()
19106 
    iprot.readStructEnd()
19107 
 
19108 
  def write(self, oprot):
19109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19111 
      return
19112 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19113 
    if self.settlementId is not None:
19114 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19115 
      oprot.writeI64(self.settlementId)
19116 
      oprot.writeFieldEnd()
19117 
    oprot.writeFieldStop()
19118 
    oprot.writeStructEnd()
19119 
 
19120 
  def validate(self):
19121 
    return
19122 
 
19123 
 
19124 
  def __repr__(self):
19125 
    L = ['%s=%r' % (key, value)
19126 
      for key, value in self.__dict__.iteritems()]
19127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19128 
 
19129 
  def __eq__(self, other):
19130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19131 
 
19132 
  def __ne__(self, other):
19133 
    return not (self == other)
19134 
 
19135 
class getEBSSettlementDate_result:
19136 
  """
19137 
  Attributes:
19138 
   - success
19139 
   - ex
19140 
  """
19141 
 
19142 
  thrift_spec = (
19143 
    (0, TType.I64, 'success', None, None, ), # 0
19144 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19145 
  )
19146 
 
19147 
  def __init__(self, success=None, ex=None,):
19148 
    self.success = success
19149 
    self.ex = ex
19150 
 
19151 
  def read(self, iprot):
19152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19154 
      return
19155 
    iprot.readStructBegin()
19156 
    while True:
19157 
      (fname, ftype, fid) = iprot.readFieldBegin()
19158 
      if ftype == TType.STOP:
19159 
        break
19160 
      if fid == 0:
19161 
        if ftype == TType.I64:
19162 
          self.success = iprot.readI64();
19163 
        else:
19164 
          iprot.skip(ftype)
19165 
      elif fid == 1:
19166 
        if ftype == TType.STRUCT:
19167 
          self.ex = TransactionServiceException()
19168 
          self.ex.read(iprot)
19169 
        else:
19170 
          iprot.skip(ftype)
19171 
      else:
19172 
        iprot.skip(ftype)
19173 
      iprot.readFieldEnd()
19174 
    iprot.readStructEnd()
19175 
 
19176 
  def write(self, oprot):
19177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19179 
      return
19180 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19181 
    if self.success is not None:
19182 
      oprot.writeFieldBegin('success', TType.I64, 0)
19183 
      oprot.writeI64(self.success)
19184 
      oprot.writeFieldEnd()
19185 
    if self.ex is not None:
19186 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19187 
      self.ex.write(oprot)
19188 
      oprot.writeFieldEnd()
19189 
    oprot.writeFieldStop()
19190 
    oprot.writeStructEnd()
19191 
 
19192 
  def validate(self):
19193 
    return
19194 
 
19195 
 
19196 
  def __repr__(self):
19197 
    L = ['%s=%r' % (key, value)
19198 
      for key, value in self.__dict__.iteritems()]
19199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19200 
 
19201 
  def __eq__(self, other):
19202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19203 
 
19204 
  def __ne__(self, other):
19205 
    return not (self == other)
4715 varun.gupt 19206 
 
19207 
class getSettlementsByDate_args:
19208 
  """
19209 
  Attributes:
19210 
   - settlementDateFrom
19211 
   - settlementDateTo
19212 
   - isRefund
19213 
  """
19214 
 
19215 
  thrift_spec = (
19216 
    None, # 0
19217 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19218 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19219 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19220 
  )
19221 
 
19222 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19223 
    self.settlementDateFrom = settlementDateFrom
19224 
    self.settlementDateTo = settlementDateTo
19225 
    self.isRefund = isRefund
19226 
 
19227 
  def read(self, iprot):
19228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19230 
      return
19231 
    iprot.readStructBegin()
19232 
    while True:
19233 
      (fname, ftype, fid) = iprot.readFieldBegin()
19234 
      if ftype == TType.STOP:
19235 
        break
19236 
      if fid == 1:
19237 
        if ftype == TType.I64:
19238 
          self.settlementDateFrom = iprot.readI64();
19239 
        else:
19240 
          iprot.skip(ftype)
19241 
      elif fid == 2:
19242 
        if ftype == TType.I64:
19243 
          self.settlementDateTo = iprot.readI64();
19244 
        else:
19245 
          iprot.skip(ftype)
19246 
      elif fid == 3:
19247 
        if ftype == TType.BOOL:
19248 
          self.isRefund = iprot.readBool();
19249 
        else:
19250 
          iprot.skip(ftype)
19251 
      else:
19252 
        iprot.skip(ftype)
19253 
      iprot.readFieldEnd()
19254 
    iprot.readStructEnd()
19255 
 
19256 
  def write(self, oprot):
19257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19259 
      return
19260 
    oprot.writeStructBegin('getSettlementsByDate_args')
19261 
    if self.settlementDateFrom is not None:
19262 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19263 
      oprot.writeI64(self.settlementDateFrom)
19264 
      oprot.writeFieldEnd()
19265 
    if self.settlementDateTo is not None:
19266 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19267 
      oprot.writeI64(self.settlementDateTo)
19268 
      oprot.writeFieldEnd()
19269 
    if self.isRefund is not None:
19270 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19271 
      oprot.writeBool(self.isRefund)
19272 
      oprot.writeFieldEnd()
19273 
    oprot.writeFieldStop()
19274 
    oprot.writeStructEnd()
19275 
 
19276 
  def validate(self):
19277 
    return
19278 
 
19279 
 
19280 
  def __repr__(self):
19281 
    L = ['%s=%r' % (key, value)
19282 
      for key, value in self.__dict__.iteritems()]
19283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19284 
 
19285 
  def __eq__(self, other):
19286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19287 
 
19288 
  def __ne__(self, other):
19289 
    return not (self == other)
19290 
 
19291 
class getSettlementsByDate_result:
19292 
  """
19293 
  Attributes:
19294 
   - success
19295 
   - ex
19296 
  """
19297 
 
19298 
  thrift_spec = (
19299 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19301 
  )
19302 
 
19303 
  def __init__(self, success=None, ex=None,):
19304 
    self.success = success
19305 
    self.ex = ex
19306 
 
19307 
  def read(self, iprot):
19308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19310 
      return
19311 
    iprot.readStructBegin()
19312 
    while True:
19313 
      (fname, ftype, fid) = iprot.readFieldBegin()
19314 
      if ftype == TType.STOP:
19315 
        break
19316 
      if fid == 0:
19317 
        if ftype == TType.LIST:
19318 
          self.success = []
4741 phani.kuma 19319 
          (_etype349, _size346) = iprot.readListBegin()
19320 
          for _i350 in xrange(_size346):
19321 
            _elem351 = PaymentSettlement()
19322 
            _elem351.read(iprot)
19323 
            self.success.append(_elem351)
4715 varun.gupt 19324 
          iprot.readListEnd()
19325 
        else:
19326 
          iprot.skip(ftype)
19327 
      elif fid == 1:
19328 
        if ftype == TType.STRUCT:
19329 
          self.ex = TransactionServiceException()
19330 
          self.ex.read(iprot)
19331 
        else:
19332 
          iprot.skip(ftype)
19333 
      else:
19334 
        iprot.skip(ftype)
19335 
      iprot.readFieldEnd()
19336 
    iprot.readStructEnd()
19337 
 
19338 
  def write(self, oprot):
19339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19341 
      return
19342 
    oprot.writeStructBegin('getSettlementsByDate_result')
19343 
    if self.success is not None:
19344 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19345 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 19346 
      for iter352 in self.success:
19347 
        iter352.write(oprot)
4715 varun.gupt 19348 
      oprot.writeListEnd()
19349 
      oprot.writeFieldEnd()
19350 
    if self.ex is not None:
19351 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19352 
      self.ex.write(oprot)
19353 
      oprot.writeFieldEnd()
19354 
    oprot.writeFieldStop()
19355 
    oprot.writeStructEnd()
19356 
 
19357 
  def validate(self):
19358 
    return
19359 
 
19360 
 
19361 
  def __repr__(self):
19362 
    L = ['%s=%r' % (key, value)
19363 
      for key, value in self.__dict__.iteritems()]
19364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19365 
 
19366 
  def __eq__(self, other):
19367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19368 
 
19369 
  def __ne__(self, other):
19370 
    return not (self == other)
19371 
 
19372 
class getReshippedOrderIds_args:
19373 
  """
19374 
  Attributes:
19375 
   - orderIds
19376 
  """
19377 
 
19378 
  thrift_spec = (
19379 
    None, # 0
19380 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19381 
  )
19382 
 
19383 
  def __init__(self, orderIds=None,):
19384 
    self.orderIds = orderIds
19385 
 
19386 
  def read(self, iprot):
19387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19389 
      return
19390 
    iprot.readStructBegin()
19391 
    while True:
19392 
      (fname, ftype, fid) = iprot.readFieldBegin()
19393 
      if ftype == TType.STOP:
19394 
        break
19395 
      if fid == 1:
19396 
        if ftype == TType.LIST:
19397 
          self.orderIds = []
4741 phani.kuma 19398 
          (_etype356, _size353) = iprot.readListBegin()
19399 
          for _i357 in xrange(_size353):
19400 
            _elem358 = iprot.readI64();
19401 
            self.orderIds.append(_elem358)
4715 varun.gupt 19402 
          iprot.readListEnd()
19403 
        else:
19404 
          iprot.skip(ftype)
19405 
      else:
19406 
        iprot.skip(ftype)
19407 
      iprot.readFieldEnd()
19408 
    iprot.readStructEnd()
19409 
 
19410 
  def write(self, oprot):
19411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19413 
      return
19414 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19415 
    if self.orderIds is not None:
19416 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19417 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4741 phani.kuma 19418 
      for iter359 in self.orderIds:
19419 
        oprot.writeI64(iter359)
4715 varun.gupt 19420 
      oprot.writeListEnd()
19421 
      oprot.writeFieldEnd()
19422 
    oprot.writeFieldStop()
19423 
    oprot.writeStructEnd()
19424 
 
19425 
  def validate(self):
19426 
    return
19427 
 
19428 
 
19429 
  def __repr__(self):
19430 
    L = ['%s=%r' % (key, value)
19431 
      for key, value in self.__dict__.iteritems()]
19432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19433 
 
19434 
  def __eq__(self, other):
19435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19436 
 
19437 
  def __ne__(self, other):
19438 
    return not (self == other)
19439 
 
19440 
class getReshippedOrderIds_result:
19441 
  """
19442 
  Attributes:
19443 
   - success
19444 
   - ex
19445 
  """
19446 
 
19447 
  thrift_spec = (
19448 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19450 
  )
19451 
 
19452 
  def __init__(self, success=None, ex=None,):
19453 
    self.success = success
19454 
    self.ex = ex
19455 
 
19456 
  def read(self, iprot):
19457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19459 
      return
19460 
    iprot.readStructBegin()
19461 
    while True:
19462 
      (fname, ftype, fid) = iprot.readFieldBegin()
19463 
      if ftype == TType.STOP:
19464 
        break
19465 
      if fid == 0:
19466 
        if ftype == TType.LIST:
19467 
          self.success = []
4741 phani.kuma 19468 
          (_etype363, _size360) = iprot.readListBegin()
19469 
          for _i364 in xrange(_size360):
19470 
            _elem365 = iprot.readI64();
19471 
            self.success.append(_elem365)
4715 varun.gupt 19472 
          iprot.readListEnd()
19473 
        else:
19474 
          iprot.skip(ftype)
19475 
      elif fid == 1:
19476 
        if ftype == TType.STRUCT:
19477 
          self.ex = TransactionServiceException()
19478 
          self.ex.read(iprot)
19479 
        else:
19480 
          iprot.skip(ftype)
19481 
      else:
19482 
        iprot.skip(ftype)
19483 
      iprot.readFieldEnd()
19484 
    iprot.readStructEnd()
19485 
 
19486 
  def write(self, oprot):
19487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19489 
      return
19490 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19491 
    if self.success is not None:
19492 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19493 
      oprot.writeListBegin(TType.I64, len(self.success))
4741 phani.kuma 19494 
      for iter366 in self.success:
19495 
        oprot.writeI64(iter366)
4715 varun.gupt 19496 
      oprot.writeListEnd()
19497 
      oprot.writeFieldEnd()
19498 
    if self.ex is not None:
19499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19500 
      self.ex.write(oprot)
19501 
      oprot.writeFieldEnd()
19502 
    oprot.writeFieldStop()
19503 
    oprot.writeStructEnd()
19504 
 
19505 
  def validate(self):
19506 
    return
19507 
 
19508 
 
19509 
  def __repr__(self):
19510 
    L = ['%s=%r' % (key, value)
19511 
      for key, value in self.__dict__.iteritems()]
19512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19513 
 
19514 
  def __eq__(self, other):
19515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19516 
 
19517 
  def __ne__(self, other):
19518 
    return not (self == other)