Subversion Repositories SmartDukaan

Rev

Rev 5447 | Rev 5527 | 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 
 
5387 rajveer 58 
  def changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5387 rajveer 64 
     - selfPickup
94 ashish 65 
    """
66 
    pass
67 
 
1398 varun.gupt 68 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 69 
    """
70 
    Parameters:
71 
     - transactionId
72 
    """
73 
    pass
74 
 
4801 anupam.sin 75 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 76 
    """
77 
    Parameters:
4801 anupam.sin 78 
     - statuses
483 rajveer 79 
     - from_date
80 
     - to_date
81 
     - warehouse_id
94 ashish 82 
    """
83 
    pass
84 
 
4133 chandransh 85 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
86 
    """
87 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
88 
    Pass the status as null and the limit as 0 to ignore them.
89 
 
90 
    Parameters:
91 
     - statuses
92 
     - offset
93 
     - limit
94 
     - warehouse_id
95 
    """
96 
    pass
97 
 
98 
  def getOrderCount(self, statuses, warehouseId):
99 
    """
100 
    Returns the count of orders with the given statuses assigned to the given warehouse.
101 
 
102 
    Parameters:
103 
     - statuses
104 
     - warehouseId
105 
    """
106 
    pass
107 
 
999 varun.gupt 108 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
109 
    """
1132 chandransh 110 
    Returns orders within a range of their billing dates
3431 rajveer 111 
 
999 varun.gupt 112 
    Parameters:
113 
     - status
114 
     - start_billing_date
115 
     - end_billing_date
116 
     - warehouse_id
117 
    """
118 
    pass
119 
 
3451 chandransh 120 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 121 
    """
122 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 123 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
124 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 125 
 
3427 chandransh 126 
    Parameters:
127 
     - fromShippingDate
128 
     - toShippingDate
129 
     - providerId
130 
     - warehouseId
3451 chandransh 131 
     - cod
3427 chandransh 132 
    """
133 
    pass
134 
 
1382 varun.gupt 135 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
136 
    """
137 
    Returns order ids for orders which can be returned
3431 rajveer 138 
 
1382 varun.gupt 139 
    Parameters:
140 
     - customer_id
141 
     - limit
142 
    """
143 
    pass
144 
 
145 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
146 
    """
147 
    Returns order ids for orders which can be cancelled
3431 rajveer 148 
 
1382 varun.gupt 149 
    Parameters:
150 
     - customer_id
151 
     - limit
152 
    """
153 
    pass
154 
 
483 rajveer 155 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 156 
    """
157 
    Parameters:
483 rajveer 158 
     - orderId
159 
     - status
160 
     - description
94 ashish 161 
    """
162 
    pass
163 
 
1528 ankur.sing 164 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 165 
    """
1528 ankur.sing 166 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
167 
    only user who owns the transaction can view its order details.
3431 rajveer 168 
 
94 ashish 169 
    Parameters:
170 
     - transactionId
1528 ankur.sing 171 
     - customerId
94 ashish 172 
    """
173 
    pass
174 
 
3014 chandransh 175 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 176 
    """
3014 chandransh 177 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
178 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 179 
 
94 ashish 180 
    Parameters:
483 rajveer 181 
     - customerId
182 
     - from_date
183 
     - to_date
3014 chandransh 184 
     - statuses
94 ashish 185 
    """
186 
    pass
187 
 
483 rajveer 188 
  def createOrder(self, order):
94 ashish 189 
    """
190 
    Parameters:
483 rajveer 191 
     - order
94 ashish 192 
    """
193 
    pass
194 
 
483 rajveer 195 
  def getOrder(self, id):
94 ashish 196 
    """
197 
    Parameters:
483 rajveer 198 
     - id
94 ashish 199 
    """
200 
    pass
201 
 
483 rajveer 202 
  def getLineItemsForOrder(self, orderId):
94 ashish 203 
    """
204 
    Parameters:
483 rajveer 205 
     - orderId
94 ashish 206 
    """
207 
    pass
208 
 
4999 phani.kuma 209 
  def getOrderList(self, order_ids):
210 
    """
211 
    Parameters:
212 
     - order_ids
213 
    """
214 
    pass
215 
 
5386 phani.kuma 216 
  def getOrderListForVendor(self, order_ids, vendorId):
217 
    """
218 
    Parameters:
219 
     - order_ids
220 
     - vendorId
221 
    """
222 
    pass
223 
 
1528 ankur.sing 224 
  def getOrderForCustomer(self, orderId, customerId):
225 
    """
226 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
227 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 228 
 
1528 ankur.sing 229 
    Parameters:
230 
     - orderId
231 
     - customerId
232 
    """
233 
    pass
234 
 
4444 rajveer 235 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 236 
    """
237 
    Parameters:
4394 rajveer 238 
     - type
4444 rajveer 239 
     - warehouseId
4394 rajveer 240 
     - status
241 
     - timestamp
3064 chandransh 242 
    """
243 
    pass
244 
 
4444 rajveer 245 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 246 
    """
247 
    Parameters:
248 
     - type
4444 rajveer 249 
     - warehouseId
4394 rajveer 250 
     - description
3064 chandransh 251 
    """
252 
    pass
253 
 
4444 rajveer 254 
  def markAlertsAsSeen(self, warehouseId):
255 
    """
256 
    Parameters:
257 
     - warehouseId
258 
    """
259 
    pass
260 
 
3064 chandransh 261 
  def getValidOrderCount(self, ):
262 
    """
263 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
264 
    """
265 
    pass
266 
 
267 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
268 
    """
269 
    Returns the number of distinct customers who have done successful transactions
270 
    """
271 
    pass
272 
 
273 
  def getValidOrdersAmountRange(self, ):
274 
    """
275 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
276 
    List contains two values, first minimum amount and second maximum amount.
277 
    """
278 
    pass
279 
 
280 
  def getValidOrders(self, limit):
281 
    """
282 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
283 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 284 
 
3064 chandransh 285 
    Parameters:
286 
     - limit
287 
    """
288 
    pass
289 
 
1220 chandransh 290 
  def batchOrders(self, warehouseId):
291 
    """
292 
    Create a batch of all the pending orders for the given warehouse.
293 
    The returned list is orderd by created_timestamp.
294 
    If there are no pending orders, an empty list is returned.
3431 rajveer 295 
 
1220 chandransh 296 
    Parameters:
297 
     - warehouseId
298 
    """
299 
    pass
300 
 
1208 chandransh 301 
  def markOrderAsOutOfStock(self, orderId):
302 
    """
303 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 304 
 
1208 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
3064 chandransh 310 
  def verifyOrder(self, orderId):
759 chandransh 311 
    """
3064 chandransh 312 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
313 
    timestamp. It is intended to be used for COD orders but can be harmlessly
314 
    used for all other orders as well.
315 
    Throws an exception if no such order exists.
3431 rajveer 316 
 
759 chandransh 317 
    Parameters:
3064 chandransh 318 
     - orderId
319 
    """
320 
    pass
321 
 
322 
  def acceptOrder(self, orderId):
323 
    """
324 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
325 
    given order is not a COD order, it also captures the payment if the same has
326 
    not been captured.
327 
    Throws an exception if no such order exists.
3431 rajveer 328 
 
3064 chandransh 329 
    Parameters:
330 
     - orderId
331 
    """
332 
    pass
333 
 
5110 mandeep.dh 334 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 335 
    """
336 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 337 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 338 
    the IMEI no. if a -1 is supplied.
339 
    Also, it generates an invoice number for the order, marks the order as
340 
    BILLED and sets the billing timestamp.
341 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 342 
 
3064 chandransh 343 
    Parameters:
344 
     - orderId
4283 anupam.sin 345 
     - invoice_number
4658 mandeep.dh 346 
     - serialNumber
3064 chandransh 347 
     - itemNumber
4283 anupam.sin 348 
     - billed_by
349 
     - jacketNumber
3064 chandransh 350 
     - billingType
5110 mandeep.dh 351 
     - fulfilmentWarehouseId
4763 rajveer 352 
     - authorize
3064 chandransh 353 
    """
354 
    pass
355 
 
4763 rajveer 356 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 357 
    """
358 
    Add the invoice number to the order.
359 
 
360 
    Parameters:
361 
     - orderId
362 
     - invoiceNumber
4763 rajveer 363 
     - color
4579 rajveer 364 
    """
365 
    pass
366 
 
4910 phani.kuma 367 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 368 
    """
369 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 370 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 371 
 
372 
    Parameters:
373 
     - warehouseId
374 
     - providerId
375 
     - cod
4910 phani.kuma 376 
     - orderIds
4410 rajveer 377 
    """
378 
    pass
379 
 
4910 phani.kuma 380 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 381 
    """
4910 phani.kuma 382 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
383 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 384 
 
3064 chandransh 385 
    Parameters:
759 chandransh 386 
     - providerId
4910 phani.kuma 387 
     - pickupDetails
759 chandransh 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 392 
    """
393 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 394 
 
1113 chandransh 395 
    Parameters:
396 
     - providerId
397 
    """
398 
    pass
399 
 
1132 chandransh 400 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
401 
    """
402 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
403 
    the name of the receiver.
404 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 405 
 
1132 chandransh 406 
    Parameters:
407 
     - providerId
408 
     - deliveredOrders
409 
    """
410 
    pass
411 
 
4910 phani.kuma 412 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 413 
    """
4910 phani.kuma 414 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1135 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - returnedOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def getRTOrders(self, providerId):
424 
    """
425 
    Returns a list of orders that were returned by courier.
426 
 
427 
    Parameters:
428 
     - providerId
429 
    """
430 
    pass
431 
 
1246 chandransh 432 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
433 
    """
434 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 435 
 
1246 chandransh 436 
    Parameters:
437 
     - providerId
438 
     - undeliveredOrders
439 
    """
440 
    pass
441 
 
4910 phani.kuma 442 
  def getNonDeliveredOrdersbyCourier(self, providerId):
443 
    """
444 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
445 
 
446 
    Parameters:
447 
     - providerId
448 
    """
449 
    pass
450 
 
451 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
452 
    """
453 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
454 
 
455 
    Parameters:
456 
     - providerId
457 
     - local_connected_orders
458 
    """
459 
    pass
460 
 
461 
  def getOrdersNotLocalConnected(self, providerId):
462 
    """
463 
    Returns a list of orders that were picked up or shipped but pending local connection.
464 
 
465 
    Parameters:
466 
     - providerId
467 
    """
468 
    pass
469 
 
470 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
471 
    """
472 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
473 
 
474 
    Parameters:
475 
     - providerId
476 
     - destination_city_reached_orders
477 
    """
478 
    pass
479 
 
480 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
481 
    """
482 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
483 
 
484 
    Parameters:
485 
     - providerId
486 
     - first_atdl_orders
487 
    """
488 
    pass
489 
 
1408 ankur.sing 490 
  def getUndeliveredOrders(self, providerId, warehouseId):
491 
    """
492 
    Returns the list of orders whose delivery time has passed but have not been
493 
    delivered yet for the given provider and warehouse. To get a complete list of
494 
    undelivered orders, pass them as -1.
495 
    Returns an empty list if no such orders exist.
3431 rajveer 496 
 
1408 ankur.sing 497 
    Parameters:
498 
     - providerId
499 
     - warehouseId
500 
    """
501 
    pass
502 
 
4783 phani.kuma 503 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
504 
    """
505 
    Returns the list of orders whose expected delivery date has passed but have not been
506 
    delivered yet.
507 
    Returns an empty list if no such orders exist.
508 
    """
509 
    pass
510 
 
2536 chandransh 511 
  def toggleDOAFlag(self, orderId):
512 
    """
513 
    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.
514 
    Returns the final flag status.
515 
    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 516 
 
2536 chandransh 517 
    Parameters:
518 
     - orderId
519 
    """
520 
    pass
1886 ankur.sing 521 
 
4712 rajveer 522 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
523 
    """
524 
    Parameters:
525 
     - orderId
526 
     - deliveryTimestamp
527 
     - receiver
528 
    """
529 
    pass
530 
 
4454 rajveer 531 
  def markOrderDoaRequestReceived(self, orderId):
532 
    """
533 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
534 
 
535 
    Parameters:
536 
     - orderId
537 
    """
538 
    pass
539 
 
540 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
541 
    """
542 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
543 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
544 
 
545 
    Parameters:
546 
     - orderId
547 
     - isAuthorized
548 
    """
549 
    pass
550 
 
4488 rajveer 551 
  def markOrderReturnRequestReceived(self, orderId):
552 
    """
553 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
554 
 
555 
    Parameters:
556 
     - orderId
557 
    """
558 
    pass
559 
 
560 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
561 
    """
562 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
563 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
564 
 
565 
    Parameters:
566 
     - orderId
567 
     - isAuthorized
568 
    """
569 
    pass
570 
 
4579 rajveer 571 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 572 
    """
573 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 574 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
575 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 576 
    For any other status, it returns false.
577 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 578 
 
2536 chandransh 579 
    Parameters:
580 
     - orderId
4579 rajveer 581 
     - providerId
2536 chandransh 582 
    """
583 
    pass
584 
 
4602 rajveer 585 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 586 
    """
4452 rajveer 587 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 588 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
589 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
590 
    	3. Returns true
2591 chandransh 591 
    If the order is in any other status, it returns false.
2536 chandransh 592 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 593 
 
2536 chandransh 594 
    Parameters:
595 
     - orderId
596 
     - pickupNumber
4602 rajveer 597 
     - providerId
2536 chandransh 598 
    """
599 
    pass
600 
 
2764 chandransh 601 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
602 
    """
603 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 604 
 
2764 chandransh 605 
    Parameters:
606 
     - providerId
607 
     - pickupDetails
608 
    """
609 
    pass
610 
 
4910 phani.kuma 611 
  def getDoasNotPickedUp(self, providerId):
612 
    """
613 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
614 
 
615 
    Parameters:
616 
     - providerId
617 
    """
618 
    pass
619 
 
4741 phani.kuma 620 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
623 
 
624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getReturnOrdersNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4479 rajveer 639 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 640 
    """
4452 rajveer 641 
    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 642 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 643 
    If the order is in any other state, it returns false.
644 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 645 
 
2591 chandransh 646 
    Parameters:
647 
     - orderId
4479 rajveer 648 
     - receiveCondition
2591 chandransh 649 
    """
650 
    pass
2536 chandransh 651 
 
2591 chandransh 652 
  def validateDoa(self, orderId, isValid):
653 
    """
4452 rajveer 654 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 655 
    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 656 
    If the order is in any other state, it returns false.
657 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 658 
 
2591 chandransh 659 
    Parameters:
660 
     - orderId
661 
     - isValid
662 
    """
663 
    pass
664 
 
4495 rajveer 665 
  def validateReturnProduct(self, orderId, isUsable):
666 
    """
667 
    Parameters:
668 
     - orderId
669 
     - isUsable
670 
    """
671 
    pass
672 
 
2616 chandransh 673 
  def reshipOrder(self, orderId):
674 
    """
4484 rajveer 675 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 676 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 677 
    	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 678 
 
679 
    If the order is in DOA_CERT_VALID state, it does the following:
680 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
681 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 682 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 683 
 
2616 chandransh 684 
    Returns the id of the newly created order.
3431 rajveer 685 
 
2616 chandransh 686 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 687 
 
2616 chandransh 688 
    Parameters:
689 
     - orderId
690 
    """
691 
    pass
2591 chandransh 692 
 
3226 chandransh 693 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 694 
    """
4484 rajveer 695 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 696 
    	1. Creates a refund request for batch processing.
697 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 698 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 699 
 
2616 chandransh 700 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
701 
    	1. Creates a refund request for batch processing.
3226 chandransh 702 
    	2. Cancels the reservation of the item in the warehouse.
703 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 704 
 
3226 chandransh 705 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
706 
    	1. Cancels the reservation of the item in the warehouse.
707 
    	2. Marks the current order as CANCELED.
708 
 
709 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
710 
 
2616 chandransh 711 
    Returns True if it is successful, False otherwise.
3431 rajveer 712 
 
2616 chandransh 713 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 714 
 
2616 chandransh 715 
    Parameters:
716 
     - orderId
3226 chandransh 717 
     - refundedBy
718 
     - reason
2616 chandransh 719 
    """
720 
    pass
721 
 
2690 chandransh 722 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
723 
    """
724 
    Get all return orders created between the from and to dates for the given warehouse.
725 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 726 
 
2690 chandransh 727 
    Parameters:
728 
     - warehouseId
729 
     - fromDate
730 
     - toDate
731 
    """
732 
    pass
2616 chandransh 733 
 
5481 phani.kuma 734 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
735 
    """
736 
    Get all return orders created between the from and to dates.
737 
 
738 
    Parameters:
739 
     - onlyNotProcessed
740 
     - fromDate
741 
     - toDate
742 
    """
743 
    pass
744 
 
2700 chandransh 745 
  def getReturnOrder(self, id):
746 
    """
747 
    Returns the ReturnOrder corresponding to the given id.
748 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 749 
 
2700 chandransh 750 
    Parameters:
751 
     - id
752 
    """
753 
    pass
754 
 
2690 chandransh 755 
  def processReturn(self, returnOrderId):
756 
    """
757 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 758 
 
2690 chandransh 759 
    Parameters:
760 
     - returnOrderId
761 
    """
762 
    pass
763 
 
3451 chandransh 764 
  def updateWeight(self, orderId, weight):
765 
    """
766 
    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 767 
 
3451 chandransh 768 
    Parameters:
769 
     - orderId
770 
     - weight
771 
    """
772 
    pass
773 
 
3469 chandransh 774 
  def changeItem(self, orderId, itemId):
775 
    """
776 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
777 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 778 
 
3469 chandransh 779 
    Parameters:
780 
     - orderId
781 
     - itemId
782 
    """
783 
    pass
784 
 
785 
  def shiftToWarehouse(self, orderId, warehouseId):
786 
    """
787 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
788 
 
789 
    Parameters:
790 
     - orderId
791 
     - warehouseId
792 
    """
793 
    pass
794 
 
4647 rajveer 795 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 796 
    """
797 
    Adds the given delay reason to the given order.
3986 chandransh 798 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 799 
    Raises an exception if no order with the given id can be found.
3469 chandransh 800 
 
3553 chandransh 801 
    Parameters:
802 
     - orderId
803 
     - delayReason
3986 chandransh 804 
     - furtherDelay
4647 rajveer 805 
     - delayReasonText
3553 chandransh 806 
    """
807 
    pass
808 
 
3956 chandransh 809 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
810 
    """
811 
    Marks the COD orders with given AWB nos. as having been processed.
812 
    Updates the captured amount for the corresponding payment.
3553 chandransh 813 
 
3956 chandransh 814 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
815 
    1. There is no order corresponding to an AWB number.
816 
    2. The captured amount for a payment exceeds the total payment.
817 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
818 
 
819 
    Parameters:
820 
     - collectedAmountMap
821 
     - xferBy
822 
     - xferTxnId
823 
     - xferDate
824 
    """
825 
    pass
826 
 
4008 mandeep.dh 827 
  def getTransactionsRequiringExtraProcessing(self, category):
828 
    """
4065 mandeep.dh 829 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 830 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 831 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 832 
 
4008 mandeep.dh 833 
    Parameters:
834 
     - category
835 
    """
836 
    pass
837 
 
838 
  def markTransactionAsProcessed(self, transactionId, category):
839 
    """
840 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 841 
    It essentially deletes the transaction id record for a particular
842 
    processing type category (if present) from DB.
843 
    This is currently used by CRM application.
4008 mandeep.dh 844 
 
845 
    Parameters:
846 
     - transactionId
847 
     - category
848 
    """
849 
    pass
850 
 
4018 chandransh 851 
  def getItemWiseRiskyOrdersCount(self, ):
852 
    """
853 
    Returns a map containing the number of risky orders keyed by item id. A risky order
854 
    is defined as one whose shipping date is about to expire.
855 
    """
856 
    pass
4008 mandeep.dh 857 
 
4295 varun.gupt 858 
  def getOrdersForItemIds(self, itemIds):
859 
    """
860 
    Returns a list of all orders which have items with given id
861 
 
862 
    Parameters:
863 
     - itemIds
864 
    """
865 
    pass
866 
 
4247 rajveer 867 
  def markOrderCancellationRequestReceived(self, orderId):
868 
    """
869 
    Mark order as cancellation request received. If customer sends request of cancellation of
870 
    a particular order, this method will be called. It will just change status of the order
871 
    depending on its current status. It also records the previous status, so that we can move
872 
    back to that status if cancellation request is denied.
4018 chandransh 873 
 
4247 rajveer 874 
    Parameters:
875 
     - orderId
876 
    """
877 
    pass
878 
 
879 
  def markOrderCancellationRequestConfirmed(self, orderId):
880 
    """
881 
    If we decide to to cancel order, CRM will call this method to move the status of order to
882 
    cancellation request confirmed. After this OM will be able to cancel the order.
883 
 
884 
    Parameters:
885 
     - orderId
886 
    """
887 
    pass
888 
 
889 
  def markOrderCancellationRequestDenied(self, orderId):
890 
    """
891 
    If we decide to not to cancel order, we will move the order ro previous status.
892 
 
893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
4258 rajveer 898 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 899 
    """
4258 rajveer 900 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
901 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 902 
 
903 
    Parameters:
4258 rajveer 904 
     - transactionId
4247 rajveer 905 
    """
906 
    pass
907 
 
4259 anupam.sin 908 
  def refundTransaction(self, transactionId, refundedBy, reason):
909 
    """
910 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
911 
    need to be cancelled
4247 rajveer 912 
 
4259 anupam.sin 913 
    Parameters:
914 
     - transactionId
915 
     - refundedBy
916 
     - reason
917 
    """
918 
    pass
919 
 
4324 mandeep.dh 920 
  def updateShipmentAddress(self, orderId, addressId):
921 
    """
922 
    Updates shipment address of an order. Delivery and shipping date estimates
923 
    etc. are also updated here.
924 
 
925 
    Throws TransactionServiceException in case address change is not
926 
    possible due to certain reasons such as new pincode in address is
927 
    not serviceable etc.
928 
 
929 
    Parameters:
930 
     - orderId
931 
     - addressId
932 
    """
933 
    pass
934 
 
4285 rajveer 935 
  def acceptOrdersForItemId(self, itemId, inventory):
936 
    """
937 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
938 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 939 
 
4285 rajveer 940 
    Parameters:
941 
     - itemId
942 
     - inventory
943 
    """
944 
    pass
945 
 
4369 rajveer 946 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 947 
    """
948 
    Parameters:
949 
     - vendorId
950 
     - itemId
951 
     - quantity
952 
     - estimate
4369 rajveer 953 
     - isReminder
4303 rajveer 954 
    """
955 
    pass
4285 rajveer 956 
 
4369 rajveer 957 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 958 
    """
959 
    Parameters:
960 
     - vendorId
961 
     - itemId
962 
     - quantity
963 
     - estimate
4369 rajveer 964 
     - isReminder
4303 rajveer 965 
    """
966 
    pass
967 
 
4369 rajveer 968 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 969 
    """
970 
    Parameters:
971 
     - vendorId
972 
     - itemId
973 
     - quantity
974 
     - estimate
4369 rajveer 975 
     - isReminder
4303 rajveer 976 
    """
977 
    pass
978 
 
4369 rajveer 979 
  def markOrdersAsTimeout(self, vendorId):
980 
    """
981 
    Parameters:
982 
     - vendorId
983 
    """
984 
    pass
4303 rajveer 985 
 
4662 rajveer 986 
  def markOrderAsLostInTransit(self, orderId):
987 
    """
988 
    Mark order as LOST_IN_TRANSIT
989 
 
990 
    Parameters:
991 
     - orderId
992 
    """
993 
    pass
994 
 
4386 anupam.sin 995 
  def getOrderForAwb(self, awb):
996 
    """
997 
    Returns the order corresponding to an AWB number
4369 rajveer 998 
 
4386 anupam.sin 999 
    Parameters:
1000 
     - awb
1001 
    """
1002 
    pass
1003 
 
4910 phani.kuma 1004 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1005 
    """
4910 phani.kuma 1006 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1007 
 
4506 phani.kuma 1008 
    Parameters:
1009 
     - logistics_provider_id
4910 phani.kuma 1010 
     - order_status_list
4506 phani.kuma 1011 
    """
1012 
    pass
1013 
 
4600 varun.gupt 1014 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1015 
    """
1016 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1017 
 
4600 varun.gupt 1018 
    Parameters:
1019 
     - vendorId
1020 
     - billingDateFrom
1021 
     - billingDateTo
1022 
    """
1023 
    pass
1024 
 
4607 rajveer 1025 
  def getSlippedSippingDateOrders(self, ):
1026 
    pass
1027 
 
4709 rajveer 1028 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1029 
    """
1030 
    Parameters:
1031 
     - cancelDateFrom
1032 
     - cancelDateTo
1033 
    """
1034 
    pass
1035 
 
4600 varun.gupt 1036 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1037 
    """
1038 
    Parameters:
1039 
     - mapAWBAndAmount
1040 
    """
1041 
    pass
1042 
 
4905 varun.gupt 1043 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1044 
    """
1045 
    Parameters:
1046 
     - settlementDate
1047 
     - paymentGatewayId
4905 varun.gupt 1048 
     - referenceId
4600 varun.gupt 1049 
     - serviceTax
1050 
     - otherCharges
1051 
     - netCollection
1052 
    """
1053 
    pass
1054 
 
1055 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1056 
    """
1057 
    Parameters:
1058 
     - settlementId
1059 
     - settlementDate
1060 
     - transactionDateFrom
1061 
     - transactionDateTo
1062 
     - amount
1063 
    """
1064 
    pass
1065 
 
5386 phani.kuma 1066 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1067 
    """
1068 
    Parameters:
5189 varun.gupt 1069 
     - referenceId
1070 
     - isRefund
4600 varun.gupt 1071 
    """
1072 
    pass
1073 
 
5386 phani.kuma 1074 
  def getSettlementForCod(self, orderId, isRefund):
1075 
    """
1076 
    Parameters:
1077 
     - orderId
1078 
     - isRefund
1079 
    """
1080 
    pass
1081 
 
4600 varun.gupt 1082 
  def getEBSSettlementSummaries(self, ):
1083 
    pass
1084 
 
1085 
  def markEBSSettlementUploaded(self, settlementId):
1086 
    """
1087 
    Parameters:
1088 
     - settlementId
1089 
    """
1090 
    pass
1091 
 
1092 
  def getEBSSettlementDate(self, settlementId):
1093 
    """
1094 
    Parameters:
1095 
     - settlementId
1096 
    """
1097 
    pass
1098 
 
4715 varun.gupt 1099 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1100 
    """
1101 
    Parameters:
1102 
     - settlementDateFrom
1103 
     - settlementDateTo
1104 
     - isRefund
1105 
    """
1106 
    pass
4600 varun.gupt 1107 
 
4715 varun.gupt 1108 
  def getReshippedOrderIds(self, orderIds):
1109 
    """
1110 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1111 
 
1112 
    Parameters:
1113 
     - orderIds
1114 
    """
1115 
    pass
1116 
 
5481 phani.kuma 1117 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1118 
    """
1119 
    Parameters:
1120 
     - vendorId
5481 phani.kuma 1121 
     - onlyVendorNotPaid
1122 
     - billingDateFrom
1123 
     - billingDateTo
4875 varun.gupt 1124 
    """
1125 
    pass
4757 mandeep.dh 1126 
 
5031 varun.gupt 1127 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1128 
    """
1129 
    Parameters:
1130 
     - startDate
1131 
     - endDate
1132 
    """
1133 
    pass
4875 varun.gupt 1134 
 
5067 varun.gupt 1135 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1136 
    """
1137 
    Parameters:
1138 
     - status
1139 
     - startDatetime
1140 
     - endDatetime
1141 
    """
1142 
    pass
5031 varun.gupt 1143 
 
5348 anupam.sin 1144 
  def updateCODAgent(self, agent, orderId):
1145 
    """
1146 
    Updates the agent who handled the COD verification call
1147 
 
1148 
    Parameters:
1149 
     - agent
1150 
     - orderId
1151 
    """
1152 
    pass
1153 
 
5099 varun.gupt 1154 
  def updateOrderAsPaidToVendor(self, orderId):
1155 
    """
1156 
    Parameters:
1157 
     - orderId
1158 
    """
1159 
    pass
5067 varun.gupt 1160 
 
5386 phani.kuma 1161 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1162 
    """
1163 
    Parameters:
1164 
     - orderId
1165 
    """
1166 
    pass
1167 
 
5208 varun.gupt 1168 
  def getRefundedOrdersMarkedPaid(self, ):
1169 
    pass
5099 varun.gupt 1170 
 
5447 anupam.sin 1171 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1172 
    """
1173 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1174 
 
5447 anupam.sin 1175 
 
1176 
    Parameters:
1177 
     - minOrderId
1178 
     - maxOrderId
1179 
    """
1180 
    pass
1181 
 
1182 
 
3376 rajveer 1183 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1184 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1185 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1186 
 
1187 
  def createTransaction(self, transaction):
1188 
    """
1189 
    Parameters:
1190 
     - transaction
1191 
    """
1192 
    self.send_createTransaction(transaction)
132 ashish 1193 
    return self.recv_createTransaction()
94 ashish 1194 
 
1195 
  def send_createTransaction(self, transaction):
1196 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1197 
    args = createTransaction_args()
1198 
    args.transaction = transaction
1199 
    args.write(self._oprot)
1200 
    self._oprot.writeMessageEnd()
1201 
    self._oprot.trans.flush()
1202 
 
1203 
  def recv_createTransaction(self, ):
1204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1205 
    if mtype == TMessageType.EXCEPTION:
1206 
      x = TApplicationException()
1207 
      x.read(self._iprot)
1208 
      self._iprot.readMessageEnd()
1209 
      raise x
1210 
    result = createTransaction_result()
1211 
    result.read(self._iprot)
1212 
    self._iprot.readMessageEnd()
3431 rajveer 1213 
    if result.success is not None:
132 ashish 1214 
      return result.success
3431 rajveer 1215 
    if result.ex is not None:
94 ashish 1216 
      raise result.ex
132 ashish 1217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1218 
 
1219 
  def getTransaction(self, id):
1220 
    """
1221 
    Parameters:
1222 
     - id
1223 
    """
1224 
    self.send_getTransaction(id)
1225 
    return self.recv_getTransaction()
1226 
 
1227 
  def send_getTransaction(self, id):
1228 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1229 
    args = getTransaction_args()
1230 
    args.id = id
1231 
    args.write(self._oprot)
1232 
    self._oprot.writeMessageEnd()
1233 
    self._oprot.trans.flush()
1234 
 
1235 
  def recv_getTransaction(self, ):
1236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1237 
    if mtype == TMessageType.EXCEPTION:
1238 
      x = TApplicationException()
1239 
      x.read(self._iprot)
1240 
      self._iprot.readMessageEnd()
1241 
      raise x
1242 
    result = getTransaction_result()
1243 
    result.read(self._iprot)
1244 
    self._iprot.readMessageEnd()
3431 rajveer 1245 
    if result.success is not None:
94 ashish 1246 
      return result.success
3431 rajveer 1247 
    if result.ex is not None:
94 ashish 1248 
      raise result.ex
1249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1250 
 
1251 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1252 
    """
1253 
    Parameters:
1254 
     - customerId
1255 
     - from_date
1256 
     - to_date
1257 
     - status
1258 
    """
1259 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1260 
    return self.recv_getTransactionsForCustomer()
1261 
 
1262 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1263 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1264 
    args = getTransactionsForCustomer_args()
1265 
    args.customerId = customerId
1266 
    args.from_date = from_date
1267 
    args.to_date = to_date
1268 
    args.status = status
1269 
    args.write(self._oprot)
1270 
    self._oprot.writeMessageEnd()
1271 
    self._oprot.trans.flush()
1272 
 
1273 
  def recv_getTransactionsForCustomer(self, ):
1274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1275 
    if mtype == TMessageType.EXCEPTION:
1276 
      x = TApplicationException()
1277 
      x.read(self._iprot)
1278 
      self._iprot.readMessageEnd()
1279 
      raise x
1280 
    result = getTransactionsForCustomer_result()
1281 
    result.read(self._iprot)
1282 
    self._iprot.readMessageEnd()
3431 rajveer 1283 
    if result.success is not None:
94 ashish 1284 
      return result.success
3431 rajveer 1285 
    if result.ex is not None:
94 ashish 1286 
      raise result.ex
1287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1288 
 
132 ashish 1289 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1290 
    """
1291 
    Parameters:
1292 
     - shoppingCartId
1293 
    """
1294 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1295 
    return self.recv_getTransactionsForShoppingCartId()
1296 
 
1297 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1298 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1299 
    args = getTransactionsForShoppingCartId_args()
1300 
    args.shoppingCartId = shoppingCartId
1301 
    args.write(self._oprot)
1302 
    self._oprot.writeMessageEnd()
1303 
    self._oprot.trans.flush()
1304 
 
1305 
  def recv_getTransactionsForShoppingCartId(self, ):
1306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1307 
    if mtype == TMessageType.EXCEPTION:
1308 
      x = TApplicationException()
1309 
      x.read(self._iprot)
1310 
      self._iprot.readMessageEnd()
1311 
      raise x
1312 
    result = getTransactionsForShoppingCartId_result()
1313 
    result.read(self._iprot)
1314 
    self._iprot.readMessageEnd()
3431 rajveer 1315 
    if result.success is not None:
132 ashish 1316 
      return result.success
3431 rajveer 1317 
    if result.ex is not None:
132 ashish 1318 
      raise result.ex
1319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1320 
 
94 ashish 1321 
  def getTransactionStatus(self, transactionId):
1322 
    """
1323 
    Parameters:
1324 
     - transactionId
1325 
    """
1326 
    self.send_getTransactionStatus(transactionId)
1327 
    return self.recv_getTransactionStatus()
1328 
 
1329 
  def send_getTransactionStatus(self, transactionId):
1330 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1331 
    args = getTransactionStatus_args()
1332 
    args.transactionId = transactionId
1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
1337 
  def recv_getTransactionStatus(self, ):
1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
1344 
    result = getTransactionStatus_result()
1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
3431 rajveer 1347 
    if result.success is not None:
94 ashish 1348 
      return result.success
3431 rajveer 1349 
    if result.ex is not None:
94 ashish 1350 
      raise result.ex
1351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1352 
 
5387 rajveer 1353 
  def changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 1354 
    """
1355 
    Parameters:
1356 
     - transactionId
1357 
     - status
1358 
     - description
5387 rajveer 1359 
     - selfPickup
94 ashish 1360 
    """
5387 rajveer 1361 
    self.send_changeTransactionStatus(transactionId, status, description, selfPickup)
94 ashish 1362 
    return self.recv_changeTransactionStatus()
1363 
 
5387 rajveer 1364 
  def send_changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 1365 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1366 
    args = changeTransactionStatus_args()
1367 
    args.transactionId = transactionId
1368 
    args.status = status
1369 
    args.description = description
5387 rajveer 1370 
    args.selfPickup = selfPickup
94 ashish 1371 
    args.write(self._oprot)
1372 
    self._oprot.writeMessageEnd()
1373 
    self._oprot.trans.flush()
1374 
 
1375 
  def recv_changeTransactionStatus(self, ):
1376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1377 
    if mtype == TMessageType.EXCEPTION:
1378 
      x = TApplicationException()
1379 
      x.read(self._iprot)
1380 
      self._iprot.readMessageEnd()
1381 
      raise x
1382 
    result = changeTransactionStatus_result()
1383 
    result.read(self._iprot)
1384 
    self._iprot.readMessageEnd()
3431 rajveer 1385 
    if result.success is not None:
94 ashish 1386 
      return result.success
3431 rajveer 1387 
    if result.ex is not None:
94 ashish 1388 
      raise result.ex
1389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1390 
 
1398 varun.gupt 1391 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1392 
    """
1393 
    Parameters:
1394 
     - transactionId
1395 
    """
1398 varun.gupt 1396 
    self.send_enqueueTransactionInfoEmail(transactionId)
1397 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1398 
 
1398 varun.gupt 1399 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1400 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1401 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1402 
    args.transactionId = transactionId
1403 
    args.write(self._oprot)
1404 
    self._oprot.writeMessageEnd()
1405 
    self._oprot.trans.flush()
1406 
 
1398 varun.gupt 1407 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1409 
    if mtype == TMessageType.EXCEPTION:
1410 
      x = TApplicationException()
1411 
      x.read(self._iprot)
1412 
      self._iprot.readMessageEnd()
1413 
      raise x
1398 varun.gupt 1414 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1415 
    result.read(self._iprot)
1416 
    self._iprot.readMessageEnd()
3431 rajveer 1417 
    if result.success is not None:
1382 varun.gupt 1418 
      return result.success
3431 rajveer 1419 
    if result.ex is not None:
1382 varun.gupt 1420 
      raise result.ex
1398 varun.gupt 1421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1422 
 
4801 anupam.sin 1423 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1424 
    """
1425 
    Parameters:
4801 anupam.sin 1426 
     - statuses
483 rajveer 1427 
     - from_date
1428 
     - to_date
1429 
     - warehouse_id
94 ashish 1430 
    """
4801 anupam.sin 1431 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1432 
    return self.recv_getAllOrders()
94 ashish 1433 
 
4801 anupam.sin 1434 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1435 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1436 
    args = getAllOrders_args()
4801 anupam.sin 1437 
    args.statuses = statuses
483 rajveer 1438 
    args.from_date = from_date
1439 
    args.to_date = to_date
1440 
    args.warehouse_id = warehouse_id
94 ashish 1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
483 rajveer 1445 
  def recv_getAllOrders(self, ):
94 ashish 1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
483 rajveer 1452 
    result = getAllOrders_result()
94 ashish 1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
3431 rajveer 1455 
    if result.success is not None:
94 ashish 1456 
      return result.success
3431 rajveer 1457 
    if result.ex is not None:
94 ashish 1458 
      raise result.ex
483 rajveer 1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1460 
 
4133 chandransh 1461 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1462 
    """
1463 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1464 
    Pass the status as null and the limit as 0 to ignore them.
1465 
 
1466 
    Parameters:
1467 
     - statuses
1468 
     - offset
1469 
     - limit
1470 
     - warehouse_id
1471 
    """
1472 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1473 
    return self.recv_getOrdersInBatch()
1474 
 
1475 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1476 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1477 
    args = getOrdersInBatch_args()
1478 
    args.statuses = statuses
1479 
    args.offset = offset
1480 
    args.limit = limit
1481 
    args.warehouse_id = warehouse_id
1482 
    args.write(self._oprot)
1483 
    self._oprot.writeMessageEnd()
1484 
    self._oprot.trans.flush()
1485 
 
1486 
  def recv_getOrdersInBatch(self, ):
1487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1488 
    if mtype == TMessageType.EXCEPTION:
1489 
      x = TApplicationException()
1490 
      x.read(self._iprot)
1491 
      self._iprot.readMessageEnd()
1492 
      raise x
1493 
    result = getOrdersInBatch_result()
1494 
    result.read(self._iprot)
1495 
    self._iprot.readMessageEnd()
1496 
    if result.success is not None:
1497 
      return result.success
1498 
    if result.ex is not None:
1499 
      raise result.ex
1500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1501 
 
1502 
  def getOrderCount(self, statuses, warehouseId):
1503 
    """
1504 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1505 
 
1506 
    Parameters:
1507 
     - statuses
1508 
     - warehouseId
1509 
    """
1510 
    self.send_getOrderCount(statuses, warehouseId)
1511 
    return self.recv_getOrderCount()
1512 
 
1513 
  def send_getOrderCount(self, statuses, warehouseId):
1514 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1515 
    args = getOrderCount_args()
1516 
    args.statuses = statuses
1517 
    args.warehouseId = warehouseId
1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_getOrderCount(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = getOrderCount_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
1532 
    if result.success is not None:
1533 
      return result.success
1534 
    if result.ex is not None:
1535 
      raise result.ex
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1537 
 
999 varun.gupt 1538 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1539 
    """
1132 chandransh 1540 
    Returns orders within a range of their billing dates
3431 rajveer 1541 
 
999 varun.gupt 1542 
    Parameters:
1543 
     - status
1544 
     - start_billing_date
1545 
     - end_billing_date
1546 
     - warehouse_id
1547 
    """
1548 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1549 
    return self.recv_getOrdersByBillingDate()
1550 
 
1551 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1552 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1553 
    args = getOrdersByBillingDate_args()
1554 
    args.status = status
1555 
    args.start_billing_date = start_billing_date
1556 
    args.end_billing_date = end_billing_date
1557 
    args.warehouse_id = warehouse_id
1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
1562 
  def recv_getOrdersByBillingDate(self, ):
1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
1569 
    result = getOrdersByBillingDate_result()
1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
3431 rajveer 1572 
    if result.success is not None:
999 varun.gupt 1573 
      return result.success
3431 rajveer 1574 
    if result.ex is not None:
999 varun.gupt 1575 
      raise result.ex
1576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1577 
 
3451 chandransh 1578 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1579 
    """
1580 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1581 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1582 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1583 
 
3427 chandransh 1584 
    Parameters:
1585 
     - fromShippingDate
1586 
     - toShippingDate
1587 
     - providerId
1588 
     - warehouseId
3451 chandransh 1589 
     - cod
3427 chandransh 1590 
    """
3451 chandransh 1591 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1592 
    return self.recv_getOrdersByShippingDate()
1593 
 
3451 chandransh 1594 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1595 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1596 
    args = getOrdersByShippingDate_args()
1597 
    args.fromShippingDate = fromShippingDate
1598 
    args.toShippingDate = toShippingDate
1599 
    args.providerId = providerId
1600 
    args.warehouseId = warehouseId
3451 chandransh 1601 
    args.cod = cod
3427 chandransh 1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getOrdersByShippingDate(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getOrdersByShippingDate_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
3427 chandransh 1617 
      return result.success
3431 rajveer 1618 
    if result.ex is not None:
3427 chandransh 1619 
      raise result.ex
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1621 
 
1382 varun.gupt 1622 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1623 
    """
1624 
    Returns order ids for orders which can be returned
3431 rajveer 1625 
 
1382 varun.gupt 1626 
    Parameters:
1627 
     - customer_id
1628 
     - limit
1629 
    """
1630 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1631 
    return self.recv_getReturnableOrdersForCustomer()
1632 
 
1633 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1634 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1635 
    args = getReturnableOrdersForCustomer_args()
1636 
    args.customer_id = customer_id
1637 
    args.limit = limit
1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_getReturnableOrdersForCustomer(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = getReturnableOrdersForCustomer_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
3431 rajveer 1652 
    if result.success is not None:
1382 varun.gupt 1653 
      return result.success
3431 rajveer 1654 
    if result.ex is not None:
1382 varun.gupt 1655 
      raise result.ex
1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1657 
 
1658 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1659 
    """
1660 
    Returns order ids for orders which can be cancelled
3431 rajveer 1661 
 
1382 varun.gupt 1662 
    Parameters:
1663 
     - customer_id
1664 
     - limit
1665 
    """
1666 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1667 
    return self.recv_getCancellableOrdersForCustomer()
1668 
 
1669 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1670 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1671 
    args = getCancellableOrdersForCustomer_args()
1672 
    args.customer_id = customer_id
1673 
    args.limit = limit
1674 
    args.write(self._oprot)
1675 
    self._oprot.writeMessageEnd()
1676 
    self._oprot.trans.flush()
1677 
 
1678 
  def recv_getCancellableOrdersForCustomer(self, ):
1679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1680 
    if mtype == TMessageType.EXCEPTION:
1681 
      x = TApplicationException()
1682 
      x.read(self._iprot)
1683 
      self._iprot.readMessageEnd()
1684 
      raise x
1685 
    result = getCancellableOrdersForCustomer_result()
1686 
    result.read(self._iprot)
1687 
    self._iprot.readMessageEnd()
3431 rajveer 1688 
    if result.success is not None:
1382 varun.gupt 1689 
      return result.success
3431 rajveer 1690 
    if result.ex is not None:
1382 varun.gupt 1691 
      raise result.ex
1692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1693 
 
483 rajveer 1694 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1695 
    """
1696 
    Parameters:
483 rajveer 1697 
     - orderId
1698 
     - status
1699 
     - description
94 ashish 1700 
    """
483 rajveer 1701 
    self.send_changeOrderStatus(orderId, status, description)
1702 
    return self.recv_changeOrderStatus()
94 ashish 1703 
 
483 rajveer 1704 
  def send_changeOrderStatus(self, orderId, status, description):
1705 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1706 
    args = changeOrderStatus_args()
1707 
    args.orderId = orderId
1708 
    args.status = status
1709 
    args.description = description
94 ashish 1710 
    args.write(self._oprot)
1711 
    self._oprot.writeMessageEnd()
1712 
    self._oprot.trans.flush()
1713 
 
483 rajveer 1714 
  def recv_changeOrderStatus(self, ):
94 ashish 1715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1716 
    if mtype == TMessageType.EXCEPTION:
1717 
      x = TApplicationException()
1718 
      x.read(self._iprot)
1719 
      self._iprot.readMessageEnd()
1720 
      raise x
483 rajveer 1721 
    result = changeOrderStatus_result()
94 ashish 1722 
    result.read(self._iprot)
1723 
    self._iprot.readMessageEnd()
3431 rajveer 1724 
    if result.success is not None:
94 ashish 1725 
      return result.success
3431 rajveer 1726 
    if result.ex is not None:
94 ashish 1727 
      raise result.ex
483 rajveer 1728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1729 
 
1528 ankur.sing 1730 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1731 
    """
1528 ankur.sing 1732 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1733 
    only user who owns the transaction can view its order details.
3431 rajveer 1734 
 
94 ashish 1735 
    Parameters:
1736 
     - transactionId
1528 ankur.sing 1737 
     - customerId
94 ashish 1738 
    """
1528 ankur.sing 1739 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1740 
    return self.recv_getOrdersForTransaction()
94 ashish 1741 
 
1528 ankur.sing 1742 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1743 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1744 
    args = getOrdersForTransaction_args()
94 ashish 1745 
    args.transactionId = transactionId
1528 ankur.sing 1746 
    args.customerId = customerId
94 ashish 1747 
    args.write(self._oprot)
1748 
    self._oprot.writeMessageEnd()
1749 
    self._oprot.trans.flush()
1750 
 
483 rajveer 1751 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1753 
    if mtype == TMessageType.EXCEPTION:
1754 
      x = TApplicationException()
1755 
      x.read(self._iprot)
1756 
      self._iprot.readMessageEnd()
1757 
      raise x
483 rajveer 1758 
    result = getOrdersForTransaction_result()
94 ashish 1759 
    result.read(self._iprot)
1760 
    self._iprot.readMessageEnd()
3431 rajveer 1761 
    if result.success is not None:
94 ashish 1762 
      return result.success
3431 rajveer 1763 
    if result.ex is not None:
94 ashish 1764 
      raise result.ex
483 rajveer 1765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1766 
 
3014 chandransh 1767 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1768 
    """
3014 chandransh 1769 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1770 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1771 
 
94 ashish 1772 
    Parameters:
483 rajveer 1773 
     - customerId
1774 
     - from_date
1775 
     - to_date
3014 chandransh 1776 
     - statuses
94 ashish 1777 
    """
3014 chandransh 1778 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1779 
    return self.recv_getOrdersForCustomer()
94 ashish 1780 
 
3014 chandransh 1781 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1782 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1783 
    args = getOrdersForCustomer_args()
1784 
    args.customerId = customerId
1785 
    args.from_date = from_date
1786 
    args.to_date = to_date
3014 chandransh 1787 
    args.statuses = statuses
94 ashish 1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
483 rajveer 1792 
  def recv_getOrdersForCustomer(self, ):
94 ashish 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
483 rajveer 1799 
    result = getOrdersForCustomer_result()
94 ashish 1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
3431 rajveer 1802 
    if result.success is not None:
94 ashish 1803 
      return result.success
3431 rajveer 1804 
    if result.ex is not None:
94 ashish 1805 
      raise result.ex
483 rajveer 1806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1807 
 
483 rajveer 1808 
  def createOrder(self, order):
94 ashish 1809 
    """
1810 
    Parameters:
483 rajveer 1811 
     - order
94 ashish 1812 
    """
483 rajveer 1813 
    self.send_createOrder(order)
1814 
    return self.recv_createOrder()
94 ashish 1815 
 
483 rajveer 1816 
  def send_createOrder(self, order):
1817 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1818 
    args = createOrder_args()
1819 
    args.order = order
94 ashish 1820 
    args.write(self._oprot)
1821 
    self._oprot.writeMessageEnd()
1822 
    self._oprot.trans.flush()
1823 
 
483 rajveer 1824 
  def recv_createOrder(self, ):
94 ashish 1825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1826 
    if mtype == TMessageType.EXCEPTION:
1827 
      x = TApplicationException()
1828 
      x.read(self._iprot)
1829 
      self._iprot.readMessageEnd()
1830 
      raise x
483 rajveer 1831 
    result = createOrder_result()
94 ashish 1832 
    result.read(self._iprot)
1833 
    self._iprot.readMessageEnd()
3431 rajveer 1834 
    if result.success is not None:
94 ashish 1835 
      return result.success
3431 rajveer 1836 
    if result.ex is not None:
94 ashish 1837 
      raise result.ex
483 rajveer 1838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1839 
 
483 rajveer 1840 
  def getOrder(self, id):
94 ashish 1841 
    """
1842 
    Parameters:
483 rajveer 1843 
     - id
94 ashish 1844 
    """
483 rajveer 1845 
    self.send_getOrder(id)
1846 
    return self.recv_getOrder()
94 ashish 1847 
 
483 rajveer 1848 
  def send_getOrder(self, id):
1849 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1850 
    args = getOrder_args()
1851 
    args.id = id
94 ashish 1852 
    args.write(self._oprot)
1853 
    self._oprot.writeMessageEnd()
1854 
    self._oprot.trans.flush()
1855 
 
483 rajveer 1856 
  def recv_getOrder(self, ):
94 ashish 1857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1858 
    if mtype == TMessageType.EXCEPTION:
1859 
      x = TApplicationException()
1860 
      x.read(self._iprot)
1861 
      self._iprot.readMessageEnd()
1862 
      raise x
483 rajveer 1863 
    result = getOrder_result()
94 ashish 1864 
    result.read(self._iprot)
1865 
    self._iprot.readMessageEnd()
3431 rajveer 1866 
    if result.success is not None:
94 ashish 1867 
      return result.success
3431 rajveer 1868 
    if result.ex is not None:
94 ashish 1869 
      raise result.ex
483 rajveer 1870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1871 
 
483 rajveer 1872 
  def getLineItemsForOrder(self, orderId):
94 ashish 1873 
    """
1874 
    Parameters:
483 rajveer 1875 
     - orderId
94 ashish 1876 
    """
483 rajveer 1877 
    self.send_getLineItemsForOrder(orderId)
1878 
    return self.recv_getLineItemsForOrder()
94 ashish 1879 
 
483 rajveer 1880 
  def send_getLineItemsForOrder(self, orderId):
1881 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1882 
    args = getLineItemsForOrder_args()
1883 
    args.orderId = orderId
94 ashish 1884 
    args.write(self._oprot)
1885 
    self._oprot.writeMessageEnd()
1886 
    self._oprot.trans.flush()
1887 
 
483 rajveer 1888 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1890 
    if mtype == TMessageType.EXCEPTION:
1891 
      x = TApplicationException()
1892 
      x.read(self._iprot)
1893 
      self._iprot.readMessageEnd()
1894 
      raise x
483 rajveer 1895 
    result = getLineItemsForOrder_result()
94 ashish 1896 
    result.read(self._iprot)
1897 
    self._iprot.readMessageEnd()
3431 rajveer 1898 
    if result.success is not None:
94 ashish 1899 
      return result.success
3431 rajveer 1900 
    if result.ex is not None:
94 ashish 1901 
      raise result.ex
483 rajveer 1902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1903 
 
4999 phani.kuma 1904 
  def getOrderList(self, order_ids):
1905 
    """
1906 
    Parameters:
1907 
     - order_ids
1908 
    """
1909 
    self.send_getOrderList(order_ids)
1910 
    return self.recv_getOrderList()
1911 
 
1912 
  def send_getOrderList(self, order_ids):
1913 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1914 
    args = getOrderList_args()
1915 
    args.order_ids = order_ids
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getOrderList(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getOrderList_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success is not None:
1931 
      return result.success
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1933 
 
5386 phani.kuma 1934 
  def getOrderListForVendor(self, order_ids, vendorId):
1935 
    """
1936 
    Parameters:
1937 
     - order_ids
1938 
     - vendorId
1939 
    """
1940 
    self.send_getOrderListForVendor(order_ids, vendorId)
1941 
    return self.recv_getOrderListForVendor()
1942 
 
1943 
  def send_getOrderListForVendor(self, order_ids, vendorId):
1944 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
1945 
    args = getOrderListForVendor_args()
1946 
    args.order_ids = order_ids
1947 
    args.vendorId = vendorId
1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
1952 
  def recv_getOrderListForVendor(self, ):
1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
1959 
    result = getOrderListForVendor_result()
1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success is not None:
1963 
      return result.success
1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
1965 
 
1528 ankur.sing 1966 
  def getOrderForCustomer(self, orderId, customerId):
1967 
    """
1968 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1969 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1970 
 
1528 ankur.sing 1971 
    Parameters:
1972 
     - orderId
1973 
     - customerId
1974 
    """
1975 
    self.send_getOrderForCustomer(orderId, customerId)
1976 
    return self.recv_getOrderForCustomer()
1977 
 
1978 
  def send_getOrderForCustomer(self, orderId, customerId):
1979 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1980 
    args = getOrderForCustomer_args()
1981 
    args.orderId = orderId
1982 
    args.customerId = customerId
1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
1987 
  def recv_getOrderForCustomer(self, ):
1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
1994 
    result = getOrderForCustomer_result()
1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
3431 rajveer 1997 
    if result.success is not None:
1528 ankur.sing 1998 
      return result.success
3431 rajveer 1999 
    if result.ex is not None:
1528 ankur.sing 2000 
      raise result.ex
2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2002 
 
4444 rajveer 2003 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2004 
    """
2005 
    Parameters:
4394 rajveer 2006 
     - type
4444 rajveer 2007 
     - warehouseId
4394 rajveer 2008 
     - status
2009 
     - timestamp
3064 chandransh 2010 
    """
4444 rajveer 2011 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2012 
    return self.recv_getAlerts()
2013 
 
4444 rajveer 2014 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2015 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2016 
    args = getAlerts_args()
4394 rajveer 2017 
    args.type = type
4444 rajveer 2018 
    args.warehouseId = warehouseId
4394 rajveer 2019 
    args.status = status
2020 
    args.timestamp = timestamp
3064 chandransh 2021 
    args.write(self._oprot)
2022 
    self._oprot.writeMessageEnd()
2023 
    self._oprot.trans.flush()
2024 
 
2025 
  def recv_getAlerts(self, ):
2026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2027 
    if mtype == TMessageType.EXCEPTION:
2028 
      x = TApplicationException()
2029 
      x.read(self._iprot)
2030 
      self._iprot.readMessageEnd()
2031 
      raise x
2032 
    result = getAlerts_result()
2033 
    result.read(self._iprot)
2034 
    self._iprot.readMessageEnd()
3431 rajveer 2035 
    if result.success is not None:
3064 chandransh 2036 
      return result.success
2037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2038 
 
4444 rajveer 2039 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2040 
    """
2041 
    Parameters:
2042 
     - type
4444 rajveer 2043 
     - warehouseId
4394 rajveer 2044 
     - description
3064 chandransh 2045 
    """
4444 rajveer 2046 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2047 
    self.recv_addAlert()
3064 chandransh 2048 
 
4444 rajveer 2049 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2050 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2051 
    args = addAlert_args()
3064 chandransh 2052 
    args.type = type
4444 rajveer 2053 
    args.warehouseId = warehouseId
4394 rajveer 2054 
    args.description = description
3064 chandransh 2055 
    args.write(self._oprot)
2056 
    self._oprot.writeMessageEnd()
2057 
    self._oprot.trans.flush()
2058 
 
4394 rajveer 2059 
  def recv_addAlert(self, ):
3064 chandransh 2060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2061 
    if mtype == TMessageType.EXCEPTION:
2062 
      x = TApplicationException()
2063 
      x.read(self._iprot)
2064 
      self._iprot.readMessageEnd()
2065 
      raise x
4394 rajveer 2066 
    result = addAlert_result()
3064 chandransh 2067 
    result.read(self._iprot)
2068 
    self._iprot.readMessageEnd()
2069 
    return
2070 
 
4444 rajveer 2071 
  def markAlertsAsSeen(self, warehouseId):
2072 
    """
2073 
    Parameters:
2074 
     - warehouseId
2075 
    """
2076 
    self.send_markAlertsAsSeen(warehouseId)
2077 
    self.recv_markAlertsAsSeen()
2078 
 
2079 
  def send_markAlertsAsSeen(self, warehouseId):
2080 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2081 
    args = markAlertsAsSeen_args()
2082 
    args.warehouseId = warehouseId
2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
2087 
  def recv_markAlertsAsSeen(self, ):
2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
2094 
    result = markAlertsAsSeen_result()
2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
2097 
    return
2098 
 
3064 chandransh 2099 
  def getValidOrderCount(self, ):
2100 
    """
2101 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2102 
    """
2103 
    self.send_getValidOrderCount()
2104 
    return self.recv_getValidOrderCount()
2105 
 
2106 
  def send_getValidOrderCount(self, ):
2107 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2108 
    args = getValidOrderCount_args()
2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
2113 
  def recv_getValidOrderCount(self, ):
2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
2120 
    result = getValidOrderCount_result()
2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
3431 rajveer 2123 
    if result.success is not None:
3064 chandransh 2124 
      return result.success
2125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2126 
 
2127 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2128 
    """
2129 
    Returns the number of distinct customers who have done successful transactions
2130 
    """
2131 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2132 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2133 
 
2134 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2135 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2136 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
2141 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
2148 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
3431 rajveer 2151 
    if result.success is not None:
3064 chandransh 2152 
      return result.success
2153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2154 
 
2155 
  def getValidOrdersAmountRange(self, ):
2156 
    """
2157 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2158 
    List contains two values, first minimum amount and second maximum amount.
2159 
    """
2160 
    self.send_getValidOrdersAmountRange()
2161 
    return self.recv_getValidOrdersAmountRange()
2162 
 
2163 
  def send_getValidOrdersAmountRange(self, ):
2164 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2165 
    args = getValidOrdersAmountRange_args()
2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
2170 
  def recv_getValidOrdersAmountRange(self, ):
2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
2177 
    result = getValidOrdersAmountRange_result()
2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
3431 rajveer 2180 
    if result.success is not None:
3064 chandransh 2181 
      return result.success
2182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2183 
 
2184 
  def getValidOrders(self, limit):
2185 
    """
2186 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2187 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2188 
 
3064 chandransh 2189 
    Parameters:
2190 
     - limit
2191 
    """
2192 
    self.send_getValidOrders(limit)
2193 
    return self.recv_getValidOrders()
2194 
 
2195 
  def send_getValidOrders(self, limit):
2196 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2197 
    args = getValidOrders_args()
2198 
    args.limit = limit
2199 
    args.write(self._oprot)
2200 
    self._oprot.writeMessageEnd()
2201 
    self._oprot.trans.flush()
2202 
 
2203 
  def recv_getValidOrders(self, ):
2204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2205 
    if mtype == TMessageType.EXCEPTION:
2206 
      x = TApplicationException()
2207 
      x.read(self._iprot)
2208 
      self._iprot.readMessageEnd()
2209 
      raise x
2210 
    result = getValidOrders_result()
2211 
    result.read(self._iprot)
2212 
    self._iprot.readMessageEnd()
3431 rajveer 2213 
    if result.success is not None:
3064 chandransh 2214 
      return result.success
2215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2216 
 
1220 chandransh 2217 
  def batchOrders(self, warehouseId):
2218 
    """
2219 
    Create a batch of all the pending orders for the given warehouse.
2220 
    The returned list is orderd by created_timestamp.
2221 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2222 
 
1220 chandransh 2223 
    Parameters:
2224 
     - warehouseId
2225 
    """
2226 
    self.send_batchOrders(warehouseId)
2227 
    return self.recv_batchOrders()
2228 
 
2229 
  def send_batchOrders(self, warehouseId):
2230 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2231 
    args = batchOrders_args()
2232 
    args.warehouseId = warehouseId
2233 
    args.write(self._oprot)
2234 
    self._oprot.writeMessageEnd()
2235 
    self._oprot.trans.flush()
2236 
 
2237 
  def recv_batchOrders(self, ):
2238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2239 
    if mtype == TMessageType.EXCEPTION:
2240 
      x = TApplicationException()
2241 
      x.read(self._iprot)
2242 
      self._iprot.readMessageEnd()
2243 
      raise x
2244 
    result = batchOrders_result()
2245 
    result.read(self._iprot)
2246 
    self._iprot.readMessageEnd()
3431 rajveer 2247 
    if result.success is not None:
1220 chandransh 2248 
      return result.success
3431 rajveer 2249 
    if result.ex is not None:
1220 chandransh 2250 
      raise result.ex
2251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2252 
 
1208 chandransh 2253 
  def markOrderAsOutOfStock(self, orderId):
2254 
    """
2255 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2256 
 
1208 chandransh 2257 
    Parameters:
2258 
     - orderId
2259 
    """
2260 
    self.send_markOrderAsOutOfStock(orderId)
2261 
    return self.recv_markOrderAsOutOfStock()
2262 
 
2263 
  def send_markOrderAsOutOfStock(self, orderId):
2264 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2265 
    args = markOrderAsOutOfStock_args()
2266 
    args.orderId = orderId
2267 
    args.write(self._oprot)
2268 
    self._oprot.writeMessageEnd()
2269 
    self._oprot.trans.flush()
2270 
 
2271 
  def recv_markOrderAsOutOfStock(self, ):
2272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2273 
    if mtype == TMessageType.EXCEPTION:
2274 
      x = TApplicationException()
2275 
      x.read(self._iprot)
2276 
      self._iprot.readMessageEnd()
2277 
      raise x
2278 
    result = markOrderAsOutOfStock_result()
2279 
    result.read(self._iprot)
2280 
    self._iprot.readMessageEnd()
3431 rajveer 2281 
    if result.success is not None:
1208 chandransh 2282 
      return result.success
3431 rajveer 2283 
    if result.ex is not None:
1208 chandransh 2284 
      raise result.ex
2285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2286 
 
3064 chandransh 2287 
  def verifyOrder(self, orderId):
759 chandransh 2288 
    """
3064 chandransh 2289 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2290 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2291 
    used for all other orders as well.
2292 
    Throws an exception if no such order exists.
3431 rajveer 2293 
 
759 chandransh 2294 
    Parameters:
3064 chandransh 2295 
     - orderId
759 chandransh 2296 
    """
3064 chandransh 2297 
    self.send_verifyOrder(orderId)
2298 
    return self.recv_verifyOrder()
759 chandransh 2299 
 
3064 chandransh 2300 
  def send_verifyOrder(self, orderId):
2301 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2302 
    args = verifyOrder_args()
2303 
    args.orderId = orderId
759 chandransh 2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
3064 chandransh 2308 
  def recv_verifyOrder(self, ):
759 chandransh 2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
3064 chandransh 2315 
    result = verifyOrder_result()
759 chandransh 2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
3431 rajveer 2318 
    if result.success is not None:
759 chandransh 2319 
      return result.success
3431 rajveer 2320 
    if result.ex is not None:
759 chandransh 2321 
      raise result.ex
3064 chandransh 2322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2323 
 
3064 chandransh 2324 
  def acceptOrder(self, orderId):
1113 chandransh 2325 
    """
3064 chandransh 2326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2327 
    given order is not a COD order, it also captures the payment if the same has
2328 
    not been captured.
2329 
    Throws an exception if no such order exists.
3431 rajveer 2330 
 
1113 chandransh 2331 
    Parameters:
3064 chandransh 2332 
     - orderId
1113 chandransh 2333 
    """
3064 chandransh 2334 
    self.send_acceptOrder(orderId)
2335 
    return self.recv_acceptOrder()
1113 chandransh 2336 
 
3064 chandransh 2337 
  def send_acceptOrder(self, orderId):
2338 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2339 
    args = acceptOrder_args()
2340 
    args.orderId = orderId
1113 chandransh 2341 
    args.write(self._oprot)
2342 
    self._oprot.writeMessageEnd()
2343 
    self._oprot.trans.flush()
2344 
 
3064 chandransh 2345 
  def recv_acceptOrder(self, ):
1113 chandransh 2346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2347 
    if mtype == TMessageType.EXCEPTION:
2348 
      x = TApplicationException()
2349 
      x.read(self._iprot)
2350 
      self._iprot.readMessageEnd()
2351 
      raise x
3064 chandransh 2352 
    result = acceptOrder_result()
1113 chandransh 2353 
    result.read(self._iprot)
2354 
    self._iprot.readMessageEnd()
3431 rajveer 2355 
    if result.success is not None:
1113 chandransh 2356 
      return result.success
3431 rajveer 2357 
    if result.ex is not None:
1113 chandransh 2358 
      raise result.ex
3064 chandransh 2359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2360 
 
5110 mandeep.dh 2361 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2362 
    """
3064 chandransh 2363 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2364 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2365 
    the IMEI no. if a -1 is supplied.
2366 
    Also, it generates an invoice number for the order, marks the order as
2367 
    BILLED and sets the billing timestamp.
2368 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2369 
 
1135 chandransh 2370 
    Parameters:
3064 chandransh 2371 
     - orderId
2372 
     - invoice_number
4658 mandeep.dh 2373 
     - serialNumber
4283 anupam.sin 2374 
     - itemNumber
3064 chandransh 2375 
     - billed_by
4264 rajveer 2376 
     - jacketNumber
4283 anupam.sin 2377 
     - billingType
5110 mandeep.dh 2378 
     - fulfilmentWarehouseId
4763 rajveer 2379 
     - authorize
1135 chandransh 2380 
    """
5110 mandeep.dh 2381 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2382 
    return self.recv_addBillingDetails()
1135 chandransh 2383 
 
5110 mandeep.dh 2384 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2385 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2386 
    args = addBillingDetails_args()
2387 
    args.orderId = orderId
2388 
    args.invoice_number = invoice_number
4658 mandeep.dh 2389 
    args.serialNumber = serialNumber
4283 anupam.sin 2390 
    args.itemNumber = itemNumber
3064 chandransh 2391 
    args.billed_by = billed_by
4264 rajveer 2392 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2393 
    args.billingType = billingType
5110 mandeep.dh 2394 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2395 
    args.authorize = authorize
1135 chandransh 2396 
    args.write(self._oprot)
2397 
    self._oprot.writeMessageEnd()
2398 
    self._oprot.trans.flush()
2399 
 
3064 chandransh 2400 
  def recv_addBillingDetails(self, ):
1135 chandransh 2401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2402 
    if mtype == TMessageType.EXCEPTION:
2403 
      x = TApplicationException()
2404 
      x.read(self._iprot)
2405 
      self._iprot.readMessageEnd()
2406 
      raise x
3064 chandransh 2407 
    result = addBillingDetails_result()
1135 chandransh 2408 
    result.read(self._iprot)
2409 
    self._iprot.readMessageEnd()
3431 rajveer 2410 
    if result.success is not None:
3064 chandransh 2411 
      return result.success
3431 rajveer 2412 
    if result.ex is not None:
1135 chandransh 2413 
      raise result.ex
3064 chandransh 2414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2415 
 
4763 rajveer 2416 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2417 
    """
2418 
    Add the invoice number to the order.
2419 
 
2420 
    Parameters:
2421 
     - orderId
2422 
     - invoiceNumber
4763 rajveer 2423 
     - color
4579 rajveer 2424 
    """
4763 rajveer 2425 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2426 
    self.recv_addInvoiceNumber()
2427 
 
4763 rajveer 2428 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2429 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2430 
    args = addInvoiceNumber_args()
2431 
    args.orderId = orderId
2432 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2433 
    args.color = color
4579 rajveer 2434 
    args.write(self._oprot)
2435 
    self._oprot.writeMessageEnd()
2436 
    self._oprot.trans.flush()
2437 
 
2438 
  def recv_addInvoiceNumber(self, ):
2439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2440 
    if mtype == TMessageType.EXCEPTION:
2441 
      x = TApplicationException()
2442 
      x.read(self._iprot)
2443 
      self._iprot.readMessageEnd()
2444 
      raise x
2445 
    result = addInvoiceNumber_result()
2446 
    result.read(self._iprot)
2447 
    self._iprot.readMessageEnd()
2448 
    if result.ex is not None:
2449 
      raise result.ex
2450 
    return
2451 
 
4910 phani.kuma 2452 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2453 
    """
3064 chandransh 2454 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2455 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2456 
 
1408 ankur.sing 2457 
    Parameters:
3064 chandransh 2458 
     - warehouseId
1408 ankur.sing 2459 
     - providerId
3064 chandransh 2460 
     - cod
4910 phani.kuma 2461 
     - orderIds
1408 ankur.sing 2462 
    """
4910 phani.kuma 2463 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2464 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2465 
 
4910 phani.kuma 2466 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2467 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2468 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2469 
    args.warehouseId = warehouseId
1408 ankur.sing 2470 
    args.providerId = providerId
3064 chandransh 2471 
    args.cod = cod
4910 phani.kuma 2472 
    args.orderIds = orderIds
1408 ankur.sing 2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
4910 phani.kuma 2477 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
4910 phani.kuma 2484 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
3431 rajveer 2487 
    if result.success is not None:
1408 ankur.sing 2488 
      return result.success
3431 rajveer 2489 
    if result.ex is not None:
3064 chandransh 2490 
      raise result.ex
4910 phani.kuma 2491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2492 
 
4910 phani.kuma 2493 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2494 
    """
4910 phani.kuma 2495 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2496 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2497 
 
2498 
    Parameters:
2499 
     - providerId
4910 phani.kuma 2500 
     - pickupDetails
4410 rajveer 2501 
    """
4910 phani.kuma 2502 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2503 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2504 
 
4910 phani.kuma 2505 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2506 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2507 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2508 
    args.providerId = providerId
4910 phani.kuma 2509 
    args.pickupDetails = pickupDetails
4410 rajveer 2510 
    args.write(self._oprot)
2511 
    self._oprot.writeMessageEnd()
2512 
    self._oprot.trans.flush()
2513 
 
4910 phani.kuma 2514 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2516 
    if mtype == TMessageType.EXCEPTION:
2517 
      x = TApplicationException()
2518 
      x.read(self._iprot)
2519 
      self._iprot.readMessageEnd()
2520 
      raise x
4910 phani.kuma 2521 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2522 
    result.read(self._iprot)
2523 
    self._iprot.readMessageEnd()
2524 
    if result.ex is not None:
2525 
      raise result.ex
4910 phani.kuma 2526 
    return
4410 rajveer 2527 
 
4910 phani.kuma 2528 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2529 
    """
3064 chandransh 2530 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2531 
 
94 ashish 2532 
    Parameters:
3064 chandransh 2533 
     - providerId
304 ashish 2534 
    """
4910 phani.kuma 2535 
    self.send_getOrdersNotPickedUp(providerId)
2536 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2537 
 
4910 phani.kuma 2538 
  def send_getOrdersNotPickedUp(self, providerId):
2539 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2540 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2541 
    args.providerId = providerId
304 ashish 2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
4910 phani.kuma 2546 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
4910 phani.kuma 2553 
    result = getOrdersNotPickedUp_result()
304 ashish 2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
3431 rajveer 2556 
    if result.success is not None:
304 ashish 2557 
      return result.success
4910 phani.kuma 2558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2559 
 
3064 chandransh 2560 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2561 
    """
3064 chandransh 2562 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2563 
    the name of the receiver.
2564 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2565 
 
304 ashish 2566 
    Parameters:
3064 chandransh 2567 
     - providerId
2568 
     - deliveredOrders
304 ashish 2569 
    """
3064 chandransh 2570 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2571 
    self.recv_markOrdersAsDelivered()
304 ashish 2572 
 
3064 chandransh 2573 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2574 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2575 
    args = markOrdersAsDelivered_args()
2576 
    args.providerId = providerId
2577 
    args.deliveredOrders = deliveredOrders
304 ashish 2578 
    args.write(self._oprot)
2579 
    self._oprot.writeMessageEnd()
2580 
    self._oprot.trans.flush()
2581 
 
3064 chandransh 2582 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2584 
    if mtype == TMessageType.EXCEPTION:
2585 
      x = TApplicationException()
2586 
      x.read(self._iprot)
2587 
      self._iprot.readMessageEnd()
2588 
      raise x
3064 chandransh 2589 
    result = markOrdersAsDelivered_result()
304 ashish 2590 
    result.read(self._iprot)
2591 
    self._iprot.readMessageEnd()
3431 rajveer 2592 
    if result.ex is not None:
3064 chandransh 2593 
      raise result.ex
304 ashish 2594 
    return
2595 
 
4910 phani.kuma 2596 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2597 
    """
4910 phani.kuma 2598 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2599 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2600 
 
3064 chandransh 2601 
    Parameters:
2602 
     - providerId
2603 
     - returnedOrders
1596 ankur.sing 2604 
    """
4910 phani.kuma 2605 
    self.send_markAsRTOrders(providerId, returnedOrders)
2606 
    self.recv_markAsRTOrders()
304 ashish 2607 
 
4910 phani.kuma 2608 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2609 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2610 
    args = markAsRTOrders_args()
3064 chandransh 2611 
    args.providerId = providerId
2612 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2613 
    args.write(self._oprot)
2614 
    self._oprot.writeMessageEnd()
2615 
    self._oprot.trans.flush()
2616 
 
4910 phani.kuma 2617 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2619 
    if mtype == TMessageType.EXCEPTION:
2620 
      x = TApplicationException()
2621 
      x.read(self._iprot)
2622 
      self._iprot.readMessageEnd()
2623 
      raise x
4910 phani.kuma 2624 
    result = markAsRTOrders_result()
1596 ankur.sing 2625 
    result.read(self._iprot)
2626 
    self._iprot.readMessageEnd()
3431 rajveer 2627 
    if result.ex is not None:
3064 chandransh 2628 
      raise result.ex
2629 
    return
1596 ankur.sing 2630 
 
4910 phani.kuma 2631 
  def getRTOrders(self, providerId):
2632 
    """
2633 
    Returns a list of orders that were returned by courier.
2634 
 
2635 
    Parameters:
2636 
     - providerId
2637 
    """
2638 
    self.send_getRTOrders(providerId)
2639 
    return self.recv_getRTOrders()
2640 
 
2641 
  def send_getRTOrders(self, providerId):
2642 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2643 
    args = getRTOrders_args()
2644 
    args.providerId = providerId
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_getRTOrders(self, ):
2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
2656 
    result = getRTOrders_result()
2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
2659 
    if result.success is not None:
2660 
      return result.success
2661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2662 
 
3064 chandransh 2663 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2664 
    """
3064 chandransh 2665 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2666 
 
3064 chandransh 2667 
    Parameters:
2668 
     - providerId
2669 
     - undeliveredOrders
1627 ankur.sing 2670 
    """
3064 chandransh 2671 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2672 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2673 
 
3064 chandransh 2674 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2675 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2676 
    args = updateNonDeliveryReason_args()
2677 
    args.providerId = providerId
2678 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
3064 chandransh 2683 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
3064 chandransh 2690 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
4910 phani.kuma 2693 
    if result.ex is not None:
2694 
      raise result.ex
2695 
    return
2696 
 
2697 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2698 
    """
2699 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2700 
 
2701 
    Parameters:
2702 
     - providerId
2703 
    """
2704 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2705 
    return self.recv_getNonDeliveredOrdersbyCourier()
2706 
 
2707 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2708 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2709 
    args = getNonDeliveredOrdersbyCourier_args()
2710 
    args.providerId = providerId
2711 
    args.write(self._oprot)
2712 
    self._oprot.writeMessageEnd()
2713 
    self._oprot.trans.flush()
2714 
 
2715 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2717 
    if mtype == TMessageType.EXCEPTION:
2718 
      x = TApplicationException()
2719 
      x.read(self._iprot)
2720 
      self._iprot.readMessageEnd()
2721 
      raise x
2722 
    result = getNonDeliveredOrdersbyCourier_result()
2723 
    result.read(self._iprot)
2724 
    self._iprot.readMessageEnd()
4581 phani.kuma 2725 
    if result.success is not None:
2726 
      return result.success
4910 phani.kuma 2727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2728 
 
2729 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2730 
    """
2731 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2732 
 
2733 
    Parameters:
2734 
     - providerId
2735 
     - local_connected_orders
2736 
    """
2737 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2738 
    self.recv_markOrdersAsLocalConnected()
2739 
 
2740 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2741 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2742 
    args = markOrdersAsLocalConnected_args()
2743 
    args.providerId = providerId
2744 
    args.local_connected_orders = local_connected_orders
2745 
    args.write(self._oprot)
2746 
    self._oprot.writeMessageEnd()
2747 
    self._oprot.trans.flush()
2748 
 
2749 
  def recv_markOrdersAsLocalConnected(self, ):
2750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2751 
    if mtype == TMessageType.EXCEPTION:
2752 
      x = TApplicationException()
2753 
      x.read(self._iprot)
2754 
      self._iprot.readMessageEnd()
2755 
      raise x
2756 
    result = markOrdersAsLocalConnected_result()
2757 
    result.read(self._iprot)
2758 
    self._iprot.readMessageEnd()
3431 rajveer 2759 
    if result.ex is not None:
3064 chandransh 2760 
      raise result.ex
4910 phani.kuma 2761 
    return
1627 ankur.sing 2762 
 
4910 phani.kuma 2763 
  def getOrdersNotLocalConnected(self, providerId):
2764 
    """
2765 
    Returns a list of orders that were picked up or shipped but pending local connection.
2766 
 
2767 
    Parameters:
2768 
     - providerId
2769 
    """
2770 
    self.send_getOrdersNotLocalConnected(providerId)
2771 
    return self.recv_getOrdersNotLocalConnected()
2772 
 
2773 
  def send_getOrdersNotLocalConnected(self, providerId):
2774 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2775 
    args = getOrdersNotLocalConnected_args()
2776 
    args.providerId = providerId
2777 
    args.write(self._oprot)
2778 
    self._oprot.writeMessageEnd()
2779 
    self._oprot.trans.flush()
2780 
 
2781 
  def recv_getOrdersNotLocalConnected(self, ):
2782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2783 
    if mtype == TMessageType.EXCEPTION:
2784 
      x = TApplicationException()
2785 
      x.read(self._iprot)
2786 
      self._iprot.readMessageEnd()
2787 
      raise x
2788 
    result = getOrdersNotLocalConnected_result()
2789 
    result.read(self._iprot)
2790 
    self._iprot.readMessageEnd()
2791 
    if result.success is not None:
2792 
      return result.success
2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2794 
 
2795 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2796 
    """
2797 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2798 
 
2799 
    Parameters:
2800 
     - providerId
2801 
     - destination_city_reached_orders
2802 
    """
2803 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2804 
    self.recv_markOrdersAsDestinationCityReached()
2805 
 
2806 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2807 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2808 
    args = markOrdersAsDestinationCityReached_args()
2809 
    args.providerId = providerId
2810 
    args.destination_city_reached_orders = destination_city_reached_orders
2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
2815 
  def recv_markOrdersAsDestinationCityReached(self, ):
2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
2822 
    result = markOrdersAsDestinationCityReached_result()
2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
2825 
    if result.ex is not None:
2826 
      raise result.ex
2827 
    return
2828 
 
2829 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2830 
    """
2831 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2832 
 
2833 
    Parameters:
2834 
     - providerId
2835 
     - first_atdl_orders
2836 
    """
2837 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2838 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2839 
 
2840 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2841 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2842 
    args = markOrdersAsFirstDeliveryAttempted_args()
2843 
    args.providerId = providerId
2844 
    args.first_atdl_orders = first_atdl_orders
2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2849 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2851 
    if mtype == TMessageType.EXCEPTION:
2852 
      x = TApplicationException()
2853 
      x.read(self._iprot)
2854 
      self._iprot.readMessageEnd()
2855 
      raise x
2856 
    result = markOrdersAsFirstDeliveryAttempted_result()
2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
2859 
    if result.ex is not None:
2860 
      raise result.ex
2861 
    return
2862 
 
3064 chandransh 2863 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2864 
    """
3064 chandransh 2865 
    Returns the list of orders whose delivery time has passed but have not been
2866 
    delivered yet for the given provider and warehouse. To get a complete list of
2867 
    undelivered orders, pass them as -1.
2868 
    Returns an empty list if no such orders exist.
3431 rajveer 2869 
 
1886 ankur.sing 2870 
    Parameters:
3064 chandransh 2871 
     - providerId
2872 
     - warehouseId
1886 ankur.sing 2873 
    """
3064 chandransh 2874 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2875 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2876 
 
3064 chandransh 2877 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2878 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2879 
    args = getUndeliveredOrders_args()
2880 
    args.providerId = providerId
2881 
    args.warehouseId = warehouseId
1886 ankur.sing 2882 
    args.write(self._oprot)
2883 
    self._oprot.writeMessageEnd()
2884 
    self._oprot.trans.flush()
2885 
 
3064 chandransh 2886 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2888 
    if mtype == TMessageType.EXCEPTION:
2889 
      x = TApplicationException()
2890 
      x.read(self._iprot)
2891 
      self._iprot.readMessageEnd()
2892 
      raise x
3064 chandransh 2893 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2894 
    result.read(self._iprot)
2895 
    self._iprot.readMessageEnd()
3431 rajveer 2896 
    if result.success is not None:
1886 ankur.sing 2897 
      return result.success
3064 chandransh 2898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2899 
 
4783 phani.kuma 2900 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2901 
    """
2902 
    Returns the list of orders whose expected delivery date has passed but have not been
2903 
    delivered yet.
2904 
    Returns an empty list if no such orders exist.
2905 
    """
2906 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2907 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2908 
 
2909 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2910 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2911 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2912 
    args.write(self._oprot)
2913 
    self._oprot.writeMessageEnd()
2914 
    self._oprot.trans.flush()
2915 
 
2916 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2918 
    if mtype == TMessageType.EXCEPTION:
2919 
      x = TApplicationException()
2920 
      x.read(self._iprot)
2921 
      self._iprot.readMessageEnd()
2922 
      raise x
2923 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2924 
    result.read(self._iprot)
2925 
    self._iprot.readMessageEnd()
2926 
    if result.success is not None:
2927 
      return result.success
2928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2929 
 
2536 chandransh 2930 
  def toggleDOAFlag(self, orderId):
2931 
    """
2932 
    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.
2933 
    Returns the final flag status.
2934 
    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 2935 
 
2536 chandransh 2936 
    Parameters:
2937 
     - orderId
2938 
    """
2939 
    self.send_toggleDOAFlag(orderId)
2940 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2941 
 
2536 chandransh 2942 
  def send_toggleDOAFlag(self, orderId):
2943 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2944 
    args = toggleDOAFlag_args()
2945 
    args.orderId = orderId
2946 
    args.write(self._oprot)
2947 
    self._oprot.writeMessageEnd()
2948 
    self._oprot.trans.flush()
2949 
 
2950 
  def recv_toggleDOAFlag(self, ):
2951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2952 
    if mtype == TMessageType.EXCEPTION:
2953 
      x = TApplicationException()
2954 
      x.read(self._iprot)
2955 
      self._iprot.readMessageEnd()
2956 
      raise x
2957 
    result = toggleDOAFlag_result()
2958 
    result.read(self._iprot)
2959 
    self._iprot.readMessageEnd()
3431 rajveer 2960 
    if result.success is not None:
2536 chandransh 2961 
      return result.success
3431 rajveer 2962 
    if result.ex is not None:
2536 chandransh 2963 
      raise result.ex
2964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2965 
 
4712 rajveer 2966 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2967 
    """
2968 
    Parameters:
2969 
     - orderId
2970 
     - deliveryTimestamp
2971 
     - receiver
2972 
    """
2973 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2974 
    self.recv_markOrderAsDelivered()
2975 
 
2976 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2977 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2978 
    args = markOrderAsDelivered_args()
2979 
    args.orderId = orderId
2980 
    args.deliveryTimestamp = deliveryTimestamp
2981 
    args.receiver = receiver
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_markOrderAsDelivered(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = markOrderAsDelivered_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
2996 
    if result.ex is not None:
2997 
      raise result.ex
2998 
    return
2999 
 
4454 rajveer 3000 
  def markOrderDoaRequestReceived(self, orderId):
3001 
    """
3002 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3003 
 
3004 
    Parameters:
3005 
     - orderId
3006 
    """
3007 
    self.send_markOrderDoaRequestReceived(orderId)
3008 
    return self.recv_markOrderDoaRequestReceived()
3009 
 
3010 
  def send_markOrderDoaRequestReceived(self, orderId):
3011 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3012 
    args = markOrderDoaRequestReceived_args()
3013 
    args.orderId = orderId
3014 
    args.write(self._oprot)
3015 
    self._oprot.writeMessageEnd()
3016 
    self._oprot.trans.flush()
3017 
 
3018 
  def recv_markOrderDoaRequestReceived(self, ):
3019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3020 
    if mtype == TMessageType.EXCEPTION:
3021 
      x = TApplicationException()
3022 
      x.read(self._iprot)
3023 
      self._iprot.readMessageEnd()
3024 
      raise x
3025 
    result = markOrderDoaRequestReceived_result()
3026 
    result.read(self._iprot)
3027 
    self._iprot.readMessageEnd()
3028 
    if result.success is not None:
3029 
      return result.success
3030 
    if result.ex is not None:
3031 
      raise result.ex
3032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3033 
 
3034 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3035 
    """
3036 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3037 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3038 
 
3039 
    Parameters:
3040 
     - orderId
3041 
     - isAuthorized
3042 
    """
3043 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3044 
    return self.recv_markOrderDoaRequestAuthorized()
3045 
 
3046 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3047 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3048 
    args = markOrderDoaRequestAuthorized_args()
3049 
    args.orderId = orderId
3050 
    args.isAuthorized = isAuthorized
3051 
    args.write(self._oprot)
3052 
    self._oprot.writeMessageEnd()
3053 
    self._oprot.trans.flush()
3054 
 
3055 
  def recv_markOrderDoaRequestAuthorized(self, ):
3056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3057 
    if mtype == TMessageType.EXCEPTION:
3058 
      x = TApplicationException()
3059 
      x.read(self._iprot)
3060 
      self._iprot.readMessageEnd()
3061 
      raise x
3062 
    result = markOrderDoaRequestAuthorized_result()
3063 
    result.read(self._iprot)
3064 
    self._iprot.readMessageEnd()
3065 
    if result.success is not None:
3066 
      return result.success
3067 
    if result.ex is not None:
3068 
      raise result.ex
3069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3070 
 
4488 rajveer 3071 
  def markOrderReturnRequestReceived(self, orderId):
3072 
    """
3073 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3074 
 
3075 
    Parameters:
3076 
     - orderId
3077 
    """
3078 
    self.send_markOrderReturnRequestReceived(orderId)
3079 
    return self.recv_markOrderReturnRequestReceived()
3080 
 
3081 
  def send_markOrderReturnRequestReceived(self, orderId):
3082 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3083 
    args = markOrderReturnRequestReceived_args()
3084 
    args.orderId = orderId
3085 
    args.write(self._oprot)
3086 
    self._oprot.writeMessageEnd()
3087 
    self._oprot.trans.flush()
3088 
 
3089 
  def recv_markOrderReturnRequestReceived(self, ):
3090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3091 
    if mtype == TMessageType.EXCEPTION:
3092 
      x = TApplicationException()
3093 
      x.read(self._iprot)
3094 
      self._iprot.readMessageEnd()
3095 
      raise x
3096 
    result = markOrderReturnRequestReceived_result()
3097 
    result.read(self._iprot)
3098 
    self._iprot.readMessageEnd()
3099 
    if result.success is not None:
3100 
      return result.success
3101 
    if result.ex is not None:
3102 
      raise result.ex
3103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3104 
 
3105 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3106 
    """
3107 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3108 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3109 
 
3110 
    Parameters:
3111 
     - orderId
3112 
     - isAuthorized
3113 
    """
3114 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3115 
    return self.recv_markOrderReturnRequestAuthorized()
3116 
 
3117 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3118 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3119 
    args = markOrderReturnRequestAuthorized_args()
3120 
    args.orderId = orderId
3121 
    args.isAuthorized = isAuthorized
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_markOrderReturnRequestAuthorized(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = markOrderReturnRequestAuthorized_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.success is not None:
3137 
      return result.success
3138 
    if result.ex is not None:
3139 
      raise result.ex
3140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3141 
 
4579 rajveer 3142 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3143 
    """
3144 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3145 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3146 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3147 
    For any other status, it returns false.
3148 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3149 
 
2536 chandransh 3150 
    Parameters:
3151 
     - orderId
4579 rajveer 3152 
     - providerId
2536 chandransh 3153 
    """
4579 rajveer 3154 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3155 
    return self.recv_requestPickupNumber()
3156 
 
4579 rajveer 3157 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3158 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3159 
    args = requestPickupNumber_args()
3160 
    args.orderId = orderId
4579 rajveer 3161 
    args.providerId = providerId
2536 chandransh 3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_requestPickupNumber(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = requestPickupNumber_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3431 rajveer 3176 
    if result.success is not None:
2536 chandransh 3177 
      return result.success
3431 rajveer 3178 
    if result.ex is not None:
2536 chandransh 3179 
      raise result.ex
3180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3181 
 
4602 rajveer 3182 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3183 
    """
4452 rajveer 3184 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3185 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3186 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3187 
    	3. Returns true
2591 chandransh 3188 
    If the order is in any other status, it returns false.
2536 chandransh 3189 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3190 
 
2536 chandransh 3191 
    Parameters:
3192 
     - orderId
3193 
     - pickupNumber
4602 rajveer 3194 
     - providerId
2536 chandransh 3195 
    """
4602 rajveer 3196 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3197 
    return self.recv_authorizePickup()
3198 
 
4602 rajveer 3199 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3200 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3201 
    args = authorizePickup_args()
3202 
    args.orderId = orderId
3203 
    args.pickupNumber = pickupNumber
4602 rajveer 3204 
    args.providerId = providerId
2536 chandransh 3205 
    args.write(self._oprot)
3206 
    self._oprot.writeMessageEnd()
3207 
    self._oprot.trans.flush()
3208 
 
3209 
  def recv_authorizePickup(self, ):
3210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3211 
    if mtype == TMessageType.EXCEPTION:
3212 
      x = TApplicationException()
3213 
      x.read(self._iprot)
3214 
      self._iprot.readMessageEnd()
3215 
      raise x
3216 
    result = authorizePickup_result()
3217 
    result.read(self._iprot)
3218 
    self._iprot.readMessageEnd()
3431 rajveer 3219 
    if result.success is not None:
2536 chandransh 3220 
      return result.success
3431 rajveer 3221 
    if result.ex is not None:
2536 chandransh 3222 
      raise result.ex
3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3224 
 
2764 chandransh 3225 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3226 
    """
3227 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3228 
 
2764 chandransh 3229 
    Parameters:
3230 
     - providerId
3231 
     - pickupDetails
3232 
    """
3233 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3234 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3235 
 
3236 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3237 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3238 
    args = markDoasAsPickedUp_args()
3239 
    args.providerId = providerId
3240 
    args.pickupDetails = pickupDetails
3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3245 
  def recv_markDoasAsPickedUp(self, ):
3246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3247 
    if mtype == TMessageType.EXCEPTION:
3248 
      x = TApplicationException()
3249 
      x.read(self._iprot)
3250 
      self._iprot.readMessageEnd()
3251 
      raise x
3252 
    result = markDoasAsPickedUp_result()
3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
4910 phani.kuma 3255 
    return
3256 
 
3257 
  def getDoasNotPickedUp(self, providerId):
3258 
    """
3259 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3260 
 
3261 
    Parameters:
3262 
     - providerId
3263 
    """
3264 
    self.send_getDoasNotPickedUp(providerId)
3265 
    return self.recv_getDoasNotPickedUp()
3266 
 
3267 
  def send_getDoasNotPickedUp(self, providerId):
3268 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3269 
    args = getDoasNotPickedUp_args()
3270 
    args.providerId = providerId
3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
3275 
  def recv_getDoasNotPickedUp(self, ):
3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
3282 
    result = getDoasNotPickedUp_result()
3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3431 rajveer 3285 
    if result.success is not None:
2764 chandransh 3286 
      return result.success
4910 phani.kuma 3287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3288 
 
4741 phani.kuma 3289 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3290 
    """
3291 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3292 
 
3293 
    Parameters:
3294 
     - providerId
3295 
     - pickupDetails
3296 
    """
3297 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3298 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3299 
 
3300 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3301 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3302 
    args = markReturnOrdersAsPickedUp_args()
3303 
    args.providerId = providerId
3304 
    args.pickupDetails = pickupDetails
3305 
    args.write(self._oprot)
3306 
    self._oprot.writeMessageEnd()
3307 
    self._oprot.trans.flush()
3308 
 
3309 
  def recv_markReturnOrdersAsPickedUp(self, ):
3310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3311 
    if mtype == TMessageType.EXCEPTION:
3312 
      x = TApplicationException()
3313 
      x.read(self._iprot)
3314 
      self._iprot.readMessageEnd()
3315 
      raise x
3316 
    result = markReturnOrdersAsPickedUp_result()
3317 
    result.read(self._iprot)
3318 
    self._iprot.readMessageEnd()
4910 phani.kuma 3319 
    return
3320 
 
3321 
  def getReturnOrdersNotPickedUp(self, providerId):
3322 
    """
3323 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3324 
 
3325 
    Parameters:
3326 
     - providerId
3327 
    """
3328 
    self.send_getReturnOrdersNotPickedUp(providerId)
3329 
    return self.recv_getReturnOrdersNotPickedUp()
3330 
 
3331 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3332 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3333 
    args = getReturnOrdersNotPickedUp_args()
3334 
    args.providerId = providerId
3335 
    args.write(self._oprot)
3336 
    self._oprot.writeMessageEnd()
3337 
    self._oprot.trans.flush()
3338 
 
3339 
  def recv_getReturnOrdersNotPickedUp(self, ):
3340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3341 
    if mtype == TMessageType.EXCEPTION:
3342 
      x = TApplicationException()
3343 
      x.read(self._iprot)
3344 
      self._iprot.readMessageEnd()
3345 
      raise x
3346 
    result = getReturnOrdersNotPickedUp_result()
3347 
    result.read(self._iprot)
3348 
    self._iprot.readMessageEnd()
4741 phani.kuma 3349 
    if result.success is not None:
3350 
      return result.success
4910 phani.kuma 3351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3352 
 
4479 rajveer 3353 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3354 
    """
4452 rajveer 3355 
    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 3356 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3357 
    If the order is in any other state, it returns false.
3358 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3359 
 
2591 chandransh 3360 
    Parameters:
3361 
     - orderId
4479 rajveer 3362 
     - receiveCondition
2591 chandransh 3363 
    """
4479 rajveer 3364 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3365 
    return self.recv_receiveReturn()
2536 chandransh 3366 
 
4479 rajveer 3367 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3368 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3369 
    args = receiveReturn_args()
2591 chandransh 3370 
    args.orderId = orderId
4479 rajveer 3371 
    args.receiveCondition = receiveCondition
2591 chandransh 3372 
    args.write(self._oprot)
3373 
    self._oprot.writeMessageEnd()
3374 
    self._oprot.trans.flush()
3375 
 
2616 chandransh 3376 
  def recv_receiveReturn(self, ):
2591 chandransh 3377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3378 
    if mtype == TMessageType.EXCEPTION:
3379 
      x = TApplicationException()
3380 
      x.read(self._iprot)
3381 
      self._iprot.readMessageEnd()
3382 
      raise x
2616 chandransh 3383 
    result = receiveReturn_result()
2591 chandransh 3384 
    result.read(self._iprot)
3385 
    self._iprot.readMessageEnd()
3431 rajveer 3386 
    if result.success is not None:
2591 chandransh 3387 
      return result.success
3431 rajveer 3388 
    if result.ex is not None:
2591 chandransh 3389 
      raise result.ex
2616 chandransh 3390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3391 
 
3392 
  def validateDoa(self, orderId, isValid):
3393 
    """
4452 rajveer 3394 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3395 
    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 3396 
    If the order is in any other state, it returns false.
3397 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3398 
 
2591 chandransh 3399 
    Parameters:
3400 
     - orderId
3401 
     - isValid
3402 
    """
3403 
    self.send_validateDoa(orderId, isValid)
3404 
    return self.recv_validateDoa()
3405 
 
3406 
  def send_validateDoa(self, orderId, isValid):
3407 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3408 
    args = validateDoa_args()
3409 
    args.orderId = orderId
3410 
    args.isValid = isValid
3411 
    args.write(self._oprot)
3412 
    self._oprot.writeMessageEnd()
3413 
    self._oprot.trans.flush()
3414 
 
3415 
  def recv_validateDoa(self, ):
3416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3417 
    if mtype == TMessageType.EXCEPTION:
3418 
      x = TApplicationException()
3419 
      x.read(self._iprot)
3420 
      self._iprot.readMessageEnd()
3421 
      raise x
3422 
    result = validateDoa_result()
3423 
    result.read(self._iprot)
3424 
    self._iprot.readMessageEnd()
3431 rajveer 3425 
    if result.success is not None:
2591 chandransh 3426 
      return result.success
3431 rajveer 3427 
    if result.ex is not None:
2591 chandransh 3428 
      raise result.ex
3429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3430 
 
4495 rajveer 3431 
  def validateReturnProduct(self, orderId, isUsable):
3432 
    """
3433 
    Parameters:
3434 
     - orderId
3435 
     - isUsable
3436 
    """
3437 
    self.send_validateReturnProduct(orderId, isUsable)
3438 
    return self.recv_validateReturnProduct()
3439 
 
3440 
  def send_validateReturnProduct(self, orderId, isUsable):
3441 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3442 
    args = validateReturnProduct_args()
3443 
    args.orderId = orderId
3444 
    args.isUsable = isUsable
3445 
    args.write(self._oprot)
3446 
    self._oprot.writeMessageEnd()
3447 
    self._oprot.trans.flush()
3448 
 
3449 
  def recv_validateReturnProduct(self, ):
3450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3451 
    if mtype == TMessageType.EXCEPTION:
3452 
      x = TApplicationException()
3453 
      x.read(self._iprot)
3454 
      self._iprot.readMessageEnd()
3455 
      raise x
3456 
    result = validateReturnProduct_result()
3457 
    result.read(self._iprot)
3458 
    self._iprot.readMessageEnd()
3459 
    if result.success is not None:
3460 
      return result.success
3461 
    if result.ex is not None:
3462 
      raise result.ex
3463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3464 
 
2616 chandransh 3465 
  def reshipOrder(self, orderId):
3466 
    """
4484 rajveer 3467 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3468 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3469 
    	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 3470 
 
3471 
    If the order is in DOA_CERT_VALID state, it does the following:
3472 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3473 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3474 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3475 
 
2616 chandransh 3476 
    Returns the id of the newly created order.
3431 rajveer 3477 
 
2616 chandransh 3478 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3479 
 
2616 chandransh 3480 
    Parameters:
3481 
     - orderId
3482 
    """
3483 
    self.send_reshipOrder(orderId)
3484 
    return self.recv_reshipOrder()
2591 chandransh 3485 
 
2616 chandransh 3486 
  def send_reshipOrder(self, orderId):
3487 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3488 
    args = reshipOrder_args()
3489 
    args.orderId = orderId
3490 
    args.write(self._oprot)
3491 
    self._oprot.writeMessageEnd()
3492 
    self._oprot.trans.flush()
3493 
 
3494 
  def recv_reshipOrder(self, ):
3495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3496 
    if mtype == TMessageType.EXCEPTION:
3497 
      x = TApplicationException()
3498 
      x.read(self._iprot)
3499 
      self._iprot.readMessageEnd()
3500 
      raise x
3501 
    result = reshipOrder_result()
3502 
    result.read(self._iprot)
3503 
    self._iprot.readMessageEnd()
3431 rajveer 3504 
    if result.success is not None:
2616 chandransh 3505 
      return result.success
3431 rajveer 3506 
    if result.ex is not None:
2616 chandransh 3507 
      raise result.ex
3508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3509 
 
3226 chandransh 3510 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3511 
    """
4484 rajveer 3512 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3513 
    	1. Creates a refund request for batch processing.
3514 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3515 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3516 
 
2616 chandransh 3517 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3518 
    	1. Creates a refund request for batch processing.
3226 chandransh 3519 
    	2. Cancels the reservation of the item in the warehouse.
3520 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3521 
 
3226 chandransh 3522 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3523 
    	1. Cancels the reservation of the item in the warehouse.
3524 
    	2. Marks the current order as CANCELED.
3525 
 
3526 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3527 
 
2616 chandransh 3528 
    Returns True if it is successful, False otherwise.
3431 rajveer 3529 
 
2616 chandransh 3530 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3531 
 
2616 chandransh 3532 
    Parameters:
3533 
     - orderId
3226 chandransh 3534 
     - refundedBy
3535 
     - reason
2616 chandransh 3536 
    """
3226 chandransh 3537 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3538 
    return self.recv_refundOrder()
3539 
 
3226 chandransh 3540 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3541 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3542 
    args = refundOrder_args()
3543 
    args.orderId = orderId
3226 chandransh 3544 
    args.refundedBy = refundedBy
3545 
    args.reason = reason
2616 chandransh 3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_refundOrder(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = refundOrder_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3431 rajveer 3560 
    if result.success is not None:
2616 chandransh 3561 
      return result.success
3431 rajveer 3562 
    if result.ex is not None:
2616 chandransh 3563 
      raise result.ex
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3565 
 
2690 chandransh 3566 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3567 
    """
3568 
    Get all return orders created between the from and to dates for the given warehouse.
3569 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3570 
 
2690 chandransh 3571 
    Parameters:
3572 
     - warehouseId
3573 
     - fromDate
3574 
     - toDate
3575 
    """
3576 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3577 
    return self.recv_getReturnOrders()
2616 chandransh 3578 
 
2690 chandransh 3579 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3580 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3581 
    args = getReturnOrders_args()
3582 
    args.warehouseId = warehouseId
3583 
    args.fromDate = fromDate
3584 
    args.toDate = toDate
3585 
    args.write(self._oprot)
3586 
    self._oprot.writeMessageEnd()
3587 
    self._oprot.trans.flush()
3588 
 
3589 
  def recv_getReturnOrders(self, ):
3590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3591 
    if mtype == TMessageType.EXCEPTION:
3592 
      x = TApplicationException()
3593 
      x.read(self._iprot)
3594 
      self._iprot.readMessageEnd()
3595 
      raise x
3596 
    result = getReturnOrders_result()
3597 
    result.read(self._iprot)
3598 
    self._iprot.readMessageEnd()
3431 rajveer 3599 
    if result.success is not None:
2690 chandransh 3600 
      return result.success
3601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3602 
 
5481 phani.kuma 3603 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3604 
    """
3605 
    Get all return orders created between the from and to dates.
3606 
 
3607 
    Parameters:
3608 
     - onlyNotProcessed
3609 
     - fromDate
3610 
     - toDate
3611 
    """
3612 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3613 
    return self.recv_getAllReturnOrders()
3614 
 
3615 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3616 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3617 
    args = getAllReturnOrders_args()
3618 
    args.onlyNotProcessed = onlyNotProcessed
3619 
    args.fromDate = fromDate
3620 
    args.toDate = toDate
3621 
    args.write(self._oprot)
3622 
    self._oprot.writeMessageEnd()
3623 
    self._oprot.trans.flush()
3624 
 
3625 
  def recv_getAllReturnOrders(self, ):
3626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3627 
    if mtype == TMessageType.EXCEPTION:
3628 
      x = TApplicationException()
3629 
      x.read(self._iprot)
3630 
      self._iprot.readMessageEnd()
3631 
      raise x
3632 
    result = getAllReturnOrders_result()
3633 
    result.read(self._iprot)
3634 
    self._iprot.readMessageEnd()
3635 
    if result.success is not None:
3636 
      return result.success
3637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3638 
 
2700 chandransh 3639 
  def getReturnOrder(self, id):
3640 
    """
3641 
    Returns the ReturnOrder corresponding to the given id.
3642 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3643 
 
2700 chandransh 3644 
    Parameters:
3645 
     - id
3646 
    """
3647 
    self.send_getReturnOrder(id)
3648 
    return self.recv_getReturnOrder()
3649 
 
3650 
  def send_getReturnOrder(self, id):
3651 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3652 
    args = getReturnOrder_args()
3653 
    args.id = id
3654 
    args.write(self._oprot)
3655 
    self._oprot.writeMessageEnd()
3656 
    self._oprot.trans.flush()
3657 
 
3658 
  def recv_getReturnOrder(self, ):
3659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3660 
    if mtype == TMessageType.EXCEPTION:
3661 
      x = TApplicationException()
3662 
      x.read(self._iprot)
3663 
      self._iprot.readMessageEnd()
3664 
      raise x
3665 
    result = getReturnOrder_result()
3666 
    result.read(self._iprot)
3667 
    self._iprot.readMessageEnd()
3431 rajveer 3668 
    if result.success is not None:
2700 chandransh 3669 
      return result.success
3431 rajveer 3670 
    if result.ex is not None:
2700 chandransh 3671 
      raise result.ex
3672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3673 
 
2690 chandransh 3674 
  def processReturn(self, returnOrderId):
3675 
    """
3676 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3677 
 
2690 chandransh 3678 
    Parameters:
3679 
     - returnOrderId
3680 
    """
3681 
    self.send_processReturn(returnOrderId)
3682 
    self.recv_processReturn()
3683 
 
3684 
  def send_processReturn(self, returnOrderId):
3685 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3686 
    args = processReturn_args()
3687 
    args.returnOrderId = returnOrderId
3688 
    args.write(self._oprot)
3689 
    self._oprot.writeMessageEnd()
3690 
    self._oprot.trans.flush()
3691 
 
3692 
  def recv_processReturn(self, ):
3693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3694 
    if mtype == TMessageType.EXCEPTION:
3695 
      x = TApplicationException()
3696 
      x.read(self._iprot)
3697 
      self._iprot.readMessageEnd()
3698 
      raise x
3699 
    result = processReturn_result()
3700 
    result.read(self._iprot)
3701 
    self._iprot.readMessageEnd()
3431 rajveer 3702 
    if result.ex is not None:
2690 chandransh 3703 
      raise result.ex
3704 
    return
3705 
 
3451 chandransh 3706 
  def updateWeight(self, orderId, weight):
3707 
    """
3708 
    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 3709 
 
3451 chandransh 3710 
    Parameters:
3711 
     - orderId
3712 
     - weight
3713 
    """
3714 
    self.send_updateWeight(orderId, weight)
3715 
    return self.recv_updateWeight()
3716 
 
3717 
  def send_updateWeight(self, orderId, weight):
3718 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3719 
    args = updateWeight_args()
3720 
    args.orderId = orderId
3721 
    args.weight = weight
3722 
    args.write(self._oprot)
3723 
    self._oprot.writeMessageEnd()
3724 
    self._oprot.trans.flush()
3725 
 
3726 
  def recv_updateWeight(self, ):
3727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3728 
    if mtype == TMessageType.EXCEPTION:
3729 
      x = TApplicationException()
3730 
      x.read(self._iprot)
3731 
      self._iprot.readMessageEnd()
3732 
      raise x
3733 
    result = updateWeight_result()
3734 
    result.read(self._iprot)
3735 
    self._iprot.readMessageEnd()
3736 
    if result.success is not None:
3737 
      return result.success
3738 
    if result.ex is not None:
3739 
      raise result.ex
3740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3741 
 
3469 chandransh 3742 
  def changeItem(self, orderId, itemId):
3743 
    """
3744 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3745 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3746 
 
3469 chandransh 3747 
    Parameters:
3748 
     - orderId
3749 
     - itemId
3750 
    """
3751 
    self.send_changeItem(orderId, itemId)
3752 
    return self.recv_changeItem()
3753 
 
3754 
  def send_changeItem(self, orderId, itemId):
3755 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3756 
    args = changeItem_args()
3757 
    args.orderId = orderId
3758 
    args.itemId = itemId
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_changeItem(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = changeItem_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    if result.ex is not None:
3776 
      raise result.ex
3777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3778 
 
3779 
  def shiftToWarehouse(self, orderId, warehouseId):
3780 
    """
3781 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3782 
 
3783 
    Parameters:
3784 
     - orderId
3785 
     - warehouseId
3786 
    """
3787 
    self.send_shiftToWarehouse(orderId, warehouseId)
3788 
    return self.recv_shiftToWarehouse()
3789 
 
3790 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3791 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3792 
    args = shiftToWarehouse_args()
3793 
    args.orderId = orderId
3794 
    args.warehouseId = warehouseId
3795 
    args.write(self._oprot)
3796 
    self._oprot.writeMessageEnd()
3797 
    self._oprot.trans.flush()
3798 
 
3799 
  def recv_shiftToWarehouse(self, ):
3800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3801 
    if mtype == TMessageType.EXCEPTION:
3802 
      x = TApplicationException()
3803 
      x.read(self._iprot)
3804 
      self._iprot.readMessageEnd()
3805 
      raise x
3806 
    result = shiftToWarehouse_result()
3807 
    result.read(self._iprot)
3808 
    self._iprot.readMessageEnd()
3809 
    if result.success is not None:
3810 
      return result.success
3811 
    if result.ex is not None:
3812 
      raise result.ex
3813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3814 
 
4647 rajveer 3815 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3816 
    """
3817 
    Adds the given delay reason to the given order.
3986 chandransh 3818 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3819 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3820 
 
3553 chandransh 3821 
    Parameters:
3822 
     - orderId
3823 
     - delayReason
3986 chandransh 3824 
     - furtherDelay
4647 rajveer 3825 
     - delayReasonText
3553 chandransh 3826 
    """
4647 rajveer 3827 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3828 
    return self.recv_addDelayReason()
3829 
 
4647 rajveer 3830 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3831 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3832 
    args = addDelayReason_args()
3833 
    args.orderId = orderId
3834 
    args.delayReason = delayReason
3986 chandransh 3835 
    args.furtherDelay = furtherDelay
4647 rajveer 3836 
    args.delayReasonText = delayReasonText
3553 chandransh 3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_addDelayReason(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = addDelayReason_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3851 
    if result.success is not None:
3852 
      return result.success
3853 
    if result.ex is not None:
3854 
      raise result.ex
3855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3856 
 
3956 chandransh 3857 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3858 
    """
3859 
    Marks the COD orders with given AWB nos. as having been processed.
3860 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3861 
 
3956 chandransh 3862 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3863 
    1. There is no order corresponding to an AWB number.
3864 
    2. The captured amount for a payment exceeds the total payment.
3865 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3866 
 
3867 
    Parameters:
3868 
     - collectedAmountMap
3869 
     - xferBy
3870 
     - xferTxnId
3871 
     - xferDate
3872 
    """
3873 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3874 
    return self.recv_reconcileCodCollection()
3875 
 
3876 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3877 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3878 
    args = reconcileCodCollection_args()
3879 
    args.collectedAmountMap = collectedAmountMap
3880 
    args.xferBy = xferBy
3881 
    args.xferTxnId = xferTxnId
3882 
    args.xferDate = xferDate
3883 
    args.write(self._oprot)
3884 
    self._oprot.writeMessageEnd()
3885 
    self._oprot.trans.flush()
3886 
 
3887 
  def recv_reconcileCodCollection(self, ):
3888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3889 
    if mtype == TMessageType.EXCEPTION:
3890 
      x = TApplicationException()
3891 
      x.read(self._iprot)
3892 
      self._iprot.readMessageEnd()
3893 
      raise x
3894 
    result = reconcileCodCollection_result()
3895 
    result.read(self._iprot)
3896 
    self._iprot.readMessageEnd()
3897 
    if result.success is not None:
3898 
      return result.success
3899 
    if result.ex is not None:
3900 
      raise result.ex
3901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3902 
 
4008 mandeep.dh 3903 
  def getTransactionsRequiringExtraProcessing(self, category):
3904 
    """
4065 mandeep.dh 3905 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3906 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3907 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3908 
 
4008 mandeep.dh 3909 
    Parameters:
3910 
     - category
3911 
    """
3912 
    self.send_getTransactionsRequiringExtraProcessing(category)
3913 
    return self.recv_getTransactionsRequiringExtraProcessing()
3914 
 
3915 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3916 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3917 
    args = getTransactionsRequiringExtraProcessing_args()
3918 
    args.category = category
3919 
    args.write(self._oprot)
3920 
    self._oprot.writeMessageEnd()
3921 
    self._oprot.trans.flush()
3922 
 
3923 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3925 
    if mtype == TMessageType.EXCEPTION:
3926 
      x = TApplicationException()
3927 
      x.read(self._iprot)
3928 
      self._iprot.readMessageEnd()
3929 
      raise x
3930 
    result = getTransactionsRequiringExtraProcessing_result()
3931 
    result.read(self._iprot)
3932 
    self._iprot.readMessageEnd()
3933 
    if result.success is not None:
3934 
      return result.success
3935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3936 
 
3937 
  def markTransactionAsProcessed(self, transactionId, category):
3938 
    """
3939 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3940 
    It essentially deletes the transaction id record for a particular
3941 
    processing type category (if present) from DB.
3942 
    This is currently used by CRM application.
4008 mandeep.dh 3943 
 
3944 
    Parameters:
3945 
     - transactionId
3946 
     - category
3947 
    """
3948 
    self.send_markTransactionAsProcessed(transactionId, category)
3949 
    self.recv_markTransactionAsProcessed()
3950 
 
3951 
  def send_markTransactionAsProcessed(self, transactionId, category):
3952 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3953 
    args = markTransactionAsProcessed_args()
3954 
    args.transactionId = transactionId
3955 
    args.category = category
3956 
    args.write(self._oprot)
3957 
    self._oprot.writeMessageEnd()
3958 
    self._oprot.trans.flush()
3959 
 
3960 
  def recv_markTransactionAsProcessed(self, ):
3961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3962 
    if mtype == TMessageType.EXCEPTION:
3963 
      x = TApplicationException()
3964 
      x.read(self._iprot)
3965 
      self._iprot.readMessageEnd()
3966 
      raise x
3967 
    result = markTransactionAsProcessed_result()
3968 
    result.read(self._iprot)
3969 
    self._iprot.readMessageEnd()
3970 
    return
3971 
 
4018 chandransh 3972 
  def getItemWiseRiskyOrdersCount(self, ):
3973 
    """
3974 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3975 
    is defined as one whose shipping date is about to expire.
3976 
    """
3977 
    self.send_getItemWiseRiskyOrdersCount()
3978 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3979 
 
4018 chandransh 3980 
  def send_getItemWiseRiskyOrdersCount(self, ):
3981 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3982 
    args = getItemWiseRiskyOrdersCount_args()
3983 
    args.write(self._oprot)
3984 
    self._oprot.writeMessageEnd()
3985 
    self._oprot.trans.flush()
3986 
 
3987 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3989 
    if mtype == TMessageType.EXCEPTION:
3990 
      x = TApplicationException()
3991 
      x.read(self._iprot)
3992 
      self._iprot.readMessageEnd()
3993 
      raise x
3994 
    result = getItemWiseRiskyOrdersCount_result()
3995 
    result.read(self._iprot)
3996 
    self._iprot.readMessageEnd()
3997 
    if result.success is not None:
3998 
      return result.success
3999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4000 
 
4295 varun.gupt 4001 
  def getOrdersForItemIds(self, itemIds):
4002 
    """
4003 
    Returns a list of all orders which have items with given id
4004 
 
4005 
    Parameters:
4006 
     - itemIds
4007 
    """
4008 
    self.send_getOrdersForItemIds(itemIds)
4009 
    return self.recv_getOrdersForItemIds()
4010 
 
4011 
  def send_getOrdersForItemIds(self, itemIds):
4012 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4013 
    args = getOrdersForItemIds_args()
4014 
    args.itemIds = itemIds
4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_getOrdersForItemIds(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = getOrdersForItemIds_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
4029 
    if result.success is not None:
4030 
      return result.success
4031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4032 
 
4247 rajveer 4033 
  def markOrderCancellationRequestReceived(self, orderId):
4034 
    """
4035 
    Mark order as cancellation request received. If customer sends request of cancellation of
4036 
    a particular order, this method will be called. It will just change status of the order
4037 
    depending on its current status. It also records the previous status, so that we can move
4038 
    back to that status if cancellation request is denied.
4018 chandransh 4039 
 
4247 rajveer 4040 
    Parameters:
4041 
     - orderId
4042 
    """
4043 
    self.send_markOrderCancellationRequestReceived(orderId)
4044 
    self.recv_markOrderCancellationRequestReceived()
4045 
 
4046 
  def send_markOrderCancellationRequestReceived(self, orderId):
4047 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4048 
    args = markOrderCancellationRequestReceived_args()
4049 
    args.orderId = orderId
4050 
    args.write(self._oprot)
4051 
    self._oprot.writeMessageEnd()
4052 
    self._oprot.trans.flush()
4053 
 
4054 
  def recv_markOrderCancellationRequestReceived(self, ):
4055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4056 
    if mtype == TMessageType.EXCEPTION:
4057 
      x = TApplicationException()
4058 
      x.read(self._iprot)
4059 
      self._iprot.readMessageEnd()
4060 
      raise x
4061 
    result = markOrderCancellationRequestReceived_result()
4062 
    result.read(self._iprot)
4063 
    self._iprot.readMessageEnd()
4064 
    if result.ex is not None:
4065 
      raise result.ex
4066 
    return
4067 
 
4068 
  def markOrderCancellationRequestConfirmed(self, orderId):
4069 
    """
4070 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4071 
    cancellation request confirmed. After this OM will be able to cancel the order.
4072 
 
4073 
    Parameters:
4074 
     - orderId
4075 
    """
4076 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4077 
    self.recv_markOrderCancellationRequestConfirmed()
4078 
 
4079 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4080 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4081 
    args = markOrderCancellationRequestConfirmed_args()
4082 
    args.orderId = orderId
4083 
    args.write(self._oprot)
4084 
    self._oprot.writeMessageEnd()
4085 
    self._oprot.trans.flush()
4086 
 
4087 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4089 
    if mtype == TMessageType.EXCEPTION:
4090 
      x = TApplicationException()
4091 
      x.read(self._iprot)
4092 
      self._iprot.readMessageEnd()
4093 
      raise x
4094 
    result = markOrderCancellationRequestConfirmed_result()
4095 
    result.read(self._iprot)
4096 
    self._iprot.readMessageEnd()
4097 
    if result.ex is not None:
4098 
      raise result.ex
4099 
    return
4100 
 
4101 
  def markOrderCancellationRequestDenied(self, orderId):
4102 
    """
4103 
    If we decide to not to cancel order, we will move the order ro previous status.
4104 
 
4105 
    Parameters:
4106 
     - orderId
4107 
    """
4108 
    self.send_markOrderCancellationRequestDenied(orderId)
4109 
    self.recv_markOrderCancellationRequestDenied()
4110 
 
4111 
  def send_markOrderCancellationRequestDenied(self, orderId):
4112 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4113 
    args = markOrderCancellationRequestDenied_args()
4114 
    args.orderId = orderId
4115 
    args.write(self._oprot)
4116 
    self._oprot.writeMessageEnd()
4117 
    self._oprot.trans.flush()
4118 
 
4119 
  def recv_markOrderCancellationRequestDenied(self, ):
4120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4121 
    if mtype == TMessageType.EXCEPTION:
4122 
      x = TApplicationException()
4123 
      x.read(self._iprot)
4124 
      self._iprot.readMessageEnd()
4125 
      raise x
4126 
    result = markOrderCancellationRequestDenied_result()
4127 
    result.read(self._iprot)
4128 
    self._iprot.readMessageEnd()
4129 
    if result.ex is not None:
4130 
      raise result.ex
4131 
    return
4132 
 
4258 rajveer 4133 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4134 
    """
4258 rajveer 4135 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4136 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4137 
 
4138 
    Parameters:
4258 rajveer 4139 
     - transactionId
4247 rajveer 4140 
    """
4258 rajveer 4141 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4142 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4143 
 
4258 rajveer 4144 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4145 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4146 
    args = markTransactionAsPaymentFlagRemoved_args()
4147 
    args.transactionId = transactionId
4247 rajveer 4148 
    args.write(self._oprot)
4149 
    self._oprot.writeMessageEnd()
4150 
    self._oprot.trans.flush()
4151 
 
4258 rajveer 4152 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4154 
    if mtype == TMessageType.EXCEPTION:
4155 
      x = TApplicationException()
4156 
      x.read(self._iprot)
4157 
      self._iprot.readMessageEnd()
4158 
      raise x
4258 rajveer 4159 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4160 
    result.read(self._iprot)
4161 
    self._iprot.readMessageEnd()
4162 
    if result.ex is not None:
4163 
      raise result.ex
4164 
    return
4165 
 
4259 anupam.sin 4166 
  def refundTransaction(self, transactionId, refundedBy, reason):
4167 
    """
4168 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4169 
    need to be cancelled
4247 rajveer 4170 
 
4259 anupam.sin 4171 
    Parameters:
4172 
     - transactionId
4173 
     - refundedBy
4174 
     - reason
4175 
    """
4176 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4177 
    self.recv_refundTransaction()
4178 
 
4179 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4180 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4181 
    args = refundTransaction_args()
4182 
    args.transactionId = transactionId
4183 
    args.refundedBy = refundedBy
4184 
    args.reason = reason
4185 
    args.write(self._oprot)
4186 
    self._oprot.writeMessageEnd()
4187 
    self._oprot.trans.flush()
4188 
 
4189 
  def recv_refundTransaction(self, ):
4190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4191 
    if mtype == TMessageType.EXCEPTION:
4192 
      x = TApplicationException()
4193 
      x.read(self._iprot)
4194 
      self._iprot.readMessageEnd()
4195 
      raise x
4196 
    result = refundTransaction_result()
4197 
    result.read(self._iprot)
4198 
    self._iprot.readMessageEnd()
4199 
    if result.ex is not None:
4200 
      raise result.ex
4201 
    return
4202 
 
4324 mandeep.dh 4203 
  def updateShipmentAddress(self, orderId, addressId):
4204 
    """
4205 
    Updates shipment address of an order. Delivery and shipping date estimates
4206 
    etc. are also updated here.
4207 
 
4208 
    Throws TransactionServiceException in case address change is not
4209 
    possible due to certain reasons such as new pincode in address is
4210 
    not serviceable etc.
4211 
 
4212 
    Parameters:
4213 
     - orderId
4214 
     - addressId
4215 
    """
4216 
    self.send_updateShipmentAddress(orderId, addressId)
4217 
    self.recv_updateShipmentAddress()
4218 
 
4219 
  def send_updateShipmentAddress(self, orderId, addressId):
4220 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4221 
    args = updateShipmentAddress_args()
4222 
    args.orderId = orderId
4223 
    args.addressId = addressId
4224 
    args.write(self._oprot)
4225 
    self._oprot.writeMessageEnd()
4226 
    self._oprot.trans.flush()
4227 
 
4228 
  def recv_updateShipmentAddress(self, ):
4229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4230 
    if mtype == TMessageType.EXCEPTION:
4231 
      x = TApplicationException()
4232 
      x.read(self._iprot)
4233 
      self._iprot.readMessageEnd()
4234 
      raise x
4235 
    result = updateShipmentAddress_result()
4236 
    result.read(self._iprot)
4237 
    self._iprot.readMessageEnd()
4238 
    if result.ex is not None:
4239 
      raise result.ex
4240 
    return
4241 
 
4285 rajveer 4242 
  def acceptOrdersForItemId(self, itemId, inventory):
4243 
    """
4244 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4245 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4246 
 
4285 rajveer 4247 
    Parameters:
4248 
     - itemId
4249 
     - inventory
4250 
    """
4251 
    self.send_acceptOrdersForItemId(itemId, inventory)
4252 
    return self.recv_acceptOrdersForItemId()
4253 
 
4254 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4255 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4256 
    args = acceptOrdersForItemId_args()
4257 
    args.itemId = itemId
4258 
    args.inventory = inventory
4259 
    args.write(self._oprot)
4260 
    self._oprot.writeMessageEnd()
4261 
    self._oprot.trans.flush()
4262 
 
4263 
  def recv_acceptOrdersForItemId(self, ):
4264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4265 
    if mtype == TMessageType.EXCEPTION:
4266 
      x = TApplicationException()
4267 
      x.read(self._iprot)
4268 
      self._iprot.readMessageEnd()
4269 
      raise x
4270 
    result = acceptOrdersForItemId_result()
4271 
    result.read(self._iprot)
4272 
    self._iprot.readMessageEnd()
4273 
    if result.success is not None:
4274 
      return result.success
4275 
    if result.ex is not None:
4276 
      raise result.ex
4277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4278 
 
4369 rajveer 4279 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4280 
    """
4281 
    Parameters:
4282 
     - vendorId
4283 
     - itemId
4284 
     - quantity
4285 
     - estimate
4369 rajveer 4286 
     - isReminder
4303 rajveer 4287 
    """
4369 rajveer 4288 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4289 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4290 
 
4369 rajveer 4291 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4292 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4293 
    args = markOrdersAsPORaised_args()
4294 
    args.vendorId = vendorId
4295 
    args.itemId = itemId
4296 
    args.quantity = quantity
4297 
    args.estimate = estimate
4369 rajveer 4298 
    args.isReminder = isReminder
4303 rajveer 4299 
    args.write(self._oprot)
4300 
    self._oprot.writeMessageEnd()
4301 
    self._oprot.trans.flush()
4302 
 
4303 
  def recv_markOrdersAsPORaised(self, ):
4304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4305 
    if mtype == TMessageType.EXCEPTION:
4306 
      x = TApplicationException()
4307 
      x.read(self._iprot)
4308 
      self._iprot.readMessageEnd()
4309 
      raise x
4310 
    result = markOrdersAsPORaised_result()
4311 
    result.read(self._iprot)
4312 
    self._iprot.readMessageEnd()
4313 
    if result.ex is not None:
4314 
      raise result.ex
4315 
    return
4316 
 
4369 rajveer 4317 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4318 
    """
4319 
    Parameters:
4320 
     - vendorId
4321 
     - itemId
4322 
     - quantity
4323 
     - estimate
4369 rajveer 4324 
     - isReminder
4303 rajveer 4325 
    """
4369 rajveer 4326 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4327 
    self.recv_markOrdersAsReversalInitiated()
4328 
 
4369 rajveer 4329 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4330 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4331 
    args = markOrdersAsReversalInitiated_args()
4332 
    args.vendorId = vendorId
4333 
    args.itemId = itemId
4334 
    args.quantity = quantity
4335 
    args.estimate = estimate
4369 rajveer 4336 
    args.isReminder = isReminder
4303 rajveer 4337 
    args.write(self._oprot)
4338 
    self._oprot.writeMessageEnd()
4339 
    self._oprot.trans.flush()
4340 
 
4341 
  def recv_markOrdersAsReversalInitiated(self, ):
4342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4343 
    if mtype == TMessageType.EXCEPTION:
4344 
      x = TApplicationException()
4345 
      x.read(self._iprot)
4346 
      self._iprot.readMessageEnd()
4347 
      raise x
4348 
    result = markOrdersAsReversalInitiated_result()
4349 
    result.read(self._iprot)
4350 
    self._iprot.readMessageEnd()
4351 
    if result.ex is not None:
4352 
      raise result.ex
4353 
    return
4354 
 
4369 rajveer 4355 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4356 
    """
4357 
    Parameters:
4358 
     - vendorId
4359 
     - itemId
4360 
     - quantity
4361 
     - estimate
4369 rajveer 4362 
     - isReminder
4303 rajveer 4363 
    """
4369 rajveer 4364 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4365 
    self.recv_markOrdersAsNotAvailabke()
4366 
 
4369 rajveer 4367 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4368 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4369 
    args = markOrdersAsNotAvailabke_args()
4370 
    args.vendorId = vendorId
4371 
    args.itemId = itemId
4372 
    args.quantity = quantity
4373 
    args.estimate = estimate
4369 rajveer 4374 
    args.isReminder = isReminder
4303 rajveer 4375 
    args.write(self._oprot)
4376 
    self._oprot.writeMessageEnd()
4377 
    self._oprot.trans.flush()
4378 
 
4379 
  def recv_markOrdersAsNotAvailabke(self, ):
4380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4381 
    if mtype == TMessageType.EXCEPTION:
4382 
      x = TApplicationException()
4383 
      x.read(self._iprot)
4384 
      self._iprot.readMessageEnd()
4385 
      raise x
4386 
    result = markOrdersAsNotAvailabke_result()
4387 
    result.read(self._iprot)
4388 
    self._iprot.readMessageEnd()
4389 
    if result.ex is not None:
4390 
      raise result.ex
4391 
    return
4392 
 
4369 rajveer 4393 
  def markOrdersAsTimeout(self, vendorId):
4394 
    """
4395 
    Parameters:
4396 
     - vendorId
4397 
    """
4398 
    self.send_markOrdersAsTimeout(vendorId)
4399 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4400 
 
4369 rajveer 4401 
  def send_markOrdersAsTimeout(self, vendorId):
4402 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4403 
    args = markOrdersAsTimeout_args()
4404 
    args.vendorId = vendorId
4405 
    args.write(self._oprot)
4406 
    self._oprot.writeMessageEnd()
4407 
    self._oprot.trans.flush()
4408 
 
4409 
  def recv_markOrdersAsTimeout(self, ):
4410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4411 
    if mtype == TMessageType.EXCEPTION:
4412 
      x = TApplicationException()
4413 
      x.read(self._iprot)
4414 
      self._iprot.readMessageEnd()
4415 
      raise x
4416 
    result = markOrdersAsTimeout_result()
4417 
    result.read(self._iprot)
4418 
    self._iprot.readMessageEnd()
4419 
    if result.success is not None:
4420 
      return result.success
4421 
    if result.ex is not None:
4422 
      raise result.ex
4423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4424 
 
4662 rajveer 4425 
  def markOrderAsLostInTransit(self, orderId):
4426 
    """
4427 
    Mark order as LOST_IN_TRANSIT
4428 
 
4429 
    Parameters:
4430 
     - orderId
4431 
    """
4432 
    self.send_markOrderAsLostInTransit(orderId)
4433 
    return self.recv_markOrderAsLostInTransit()
4434 
 
4435 
  def send_markOrderAsLostInTransit(self, orderId):
4436 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4437 
    args = markOrderAsLostInTransit_args()
4438 
    args.orderId = orderId
4439 
    args.write(self._oprot)
4440 
    self._oprot.writeMessageEnd()
4441 
    self._oprot.trans.flush()
4442 
 
4443 
  def recv_markOrderAsLostInTransit(self, ):
4444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4445 
    if mtype == TMessageType.EXCEPTION:
4446 
      x = TApplicationException()
4447 
      x.read(self._iprot)
4448 
      self._iprot.readMessageEnd()
4449 
      raise x
4450 
    result = markOrderAsLostInTransit_result()
4451 
    result.read(self._iprot)
4452 
    self._iprot.readMessageEnd()
4453 
    if result.success is not None:
4454 
      return result.success
4455 
    if result.ex is not None:
4456 
      raise result.ex
4457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4458 
 
4386 anupam.sin 4459 
  def getOrderForAwb(self, awb):
4460 
    """
4461 
    Returns the order corresponding to an AWB number
4369 rajveer 4462 
 
4386 anupam.sin 4463 
    Parameters:
4464 
     - awb
4465 
    """
4466 
    self.send_getOrderForAwb(awb)
4467 
    return self.recv_getOrderForAwb()
4468 
 
4469 
  def send_getOrderForAwb(self, awb):
4470 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4471 
    args = getOrderForAwb_args()
4472 
    args.awb = awb
4473 
    args.write(self._oprot)
4474 
    self._oprot.writeMessageEnd()
4475 
    self._oprot.trans.flush()
4476 
 
4477 
  def recv_getOrderForAwb(self, ):
4478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4479 
    if mtype == TMessageType.EXCEPTION:
4480 
      x = TApplicationException()
4481 
      x.read(self._iprot)
4482 
      self._iprot.readMessageEnd()
4483 
      raise x
4484 
    result = getOrderForAwb_result()
4485 
    result.read(self._iprot)
4486 
    self._iprot.readMessageEnd()
4487 
    if result.success is not None:
4488 
      return result.success
4489 
    if result.ex is not None:
4490 
      raise result.ex
4491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4492 
 
4910 phani.kuma 4493 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4494 
    """
4910 phani.kuma 4495 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4496 
 
4506 phani.kuma 4497 
    Parameters:
4498 
     - logistics_provider_id
4910 phani.kuma 4499 
     - order_status_list
4506 phani.kuma 4500 
    """
4910 phani.kuma 4501 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4502 
    return self.recv_getOrdersForProviderForStatus()
4503 
 
4910 phani.kuma 4504 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4505 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4506 
    args = getOrdersForProviderForStatus_args()
4507 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4508 
    args.order_status_list = order_status_list
4506 phani.kuma 4509 
    args.write(self._oprot)
4510 
    self._oprot.writeMessageEnd()
4511 
    self._oprot.trans.flush()
4512 
 
4513 
  def recv_getOrdersForProviderForStatus(self, ):
4514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4515 
    if mtype == TMessageType.EXCEPTION:
4516 
      x = TApplicationException()
4517 
      x.read(self._iprot)
4518 
      self._iprot.readMessageEnd()
4519 
      raise x
4520 
    result = getOrdersForProviderForStatus_result()
4521 
    result.read(self._iprot)
4522 
    self._iprot.readMessageEnd()
4523 
    if result.success is not None:
4524 
      return result.success
4525 
    if result.ex is not None:
4526 
      raise result.ex
4527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4528 
 
4600 varun.gupt 4529 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4530 
    """
4531 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4532 
 
4600 varun.gupt 4533 
    Parameters:
4534 
     - vendorId
4535 
     - billingDateFrom
4536 
     - billingDateTo
4537 
    """
4538 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4539 
    return self.recv_getBilledOrdersForVendor()
4540 
 
4541 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4542 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4543 
    args = getBilledOrdersForVendor_args()
4544 
    args.vendorId = vendorId
4545 
    args.billingDateFrom = billingDateFrom
4546 
    args.billingDateTo = billingDateTo
4547 
    args.write(self._oprot)
4548 
    self._oprot.writeMessageEnd()
4549 
    self._oprot.trans.flush()
4550 
 
4551 
  def recv_getBilledOrdersForVendor(self, ):
4552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4553 
    if mtype == TMessageType.EXCEPTION:
4554 
      x = TApplicationException()
4555 
      x.read(self._iprot)
4556 
      self._iprot.readMessageEnd()
4557 
      raise x
4558 
    result = getBilledOrdersForVendor_result()
4559 
    result.read(self._iprot)
4560 
    self._iprot.readMessageEnd()
4561 
    if result.success is not None:
4562 
      return result.success
4563 
    if result.ex is not None:
4564 
      raise result.ex
4565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4566 
 
4607 rajveer 4567 
  def getSlippedSippingDateOrders(self, ):
4568 
    self.send_getSlippedSippingDateOrders()
4569 
    return self.recv_getSlippedSippingDateOrders()
4570 
 
4571 
  def send_getSlippedSippingDateOrders(self, ):
4572 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4573 
    args = getSlippedSippingDateOrders_args()
4574 
    args.write(self._oprot)
4575 
    self._oprot.writeMessageEnd()
4576 
    self._oprot.trans.flush()
4577 
 
4578 
  def recv_getSlippedSippingDateOrders(self, ):
4579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4580 
    if mtype == TMessageType.EXCEPTION:
4581 
      x = TApplicationException()
4582 
      x.read(self._iprot)
4583 
      self._iprot.readMessageEnd()
4584 
      raise x
4585 
    result = getSlippedSippingDateOrders_result()
4586 
    result.read(self._iprot)
4587 
    self._iprot.readMessageEnd()
4588 
    if result.success is not None:
4589 
      return result.success
4590 
    if result.ex is not None:
4591 
      raise result.ex
4592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4593 
 
4709 rajveer 4594 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4595 
    """
4596 
    Parameters:
4597 
     - cancelDateFrom
4598 
     - cancelDateTo
4599 
    """
4600 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4601 
    return self.recv_getCancelledOrders()
4602 
 
4603 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4604 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4605 
    args = getCancelledOrders_args()
4606 
    args.cancelDateFrom = cancelDateFrom
4607 
    args.cancelDateTo = cancelDateTo
4608 
    args.write(self._oprot)
4609 
    self._oprot.writeMessageEnd()
4610 
    self._oprot.trans.flush()
4611 
 
4612 
  def recv_getCancelledOrders(self, ):
4613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4614 
    if mtype == TMessageType.EXCEPTION:
4615 
      x = TApplicationException()
4616 
      x.read(self._iprot)
4617 
      self._iprot.readMessageEnd()
4618 
      raise x
4619 
    result = getCancelledOrders_result()
4620 
    result.read(self._iprot)
4621 
    self._iprot.readMessageEnd()
4622 
    if result.success is not None:
4623 
      return result.success
4624 
    if result.ex is not None:
4625 
      raise result.ex
4626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4627 
 
4600 varun.gupt 4628 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4629 
    """
4630 
    Parameters:
4631 
     - mapAWBAndAmount
4632 
    """
4633 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4634 
    self.recv_saveBluedartSettlements()
4635 
 
4636 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4637 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4638 
    args = saveBluedartSettlements_args()
4639 
    args.mapAWBAndAmount = mapAWBAndAmount
4640 
    args.write(self._oprot)
4641 
    self._oprot.writeMessageEnd()
4642 
    self._oprot.trans.flush()
4643 
 
4644 
  def recv_saveBluedartSettlements(self, ):
4645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4646 
    if mtype == TMessageType.EXCEPTION:
4647 
      x = TApplicationException()
4648 
      x.read(self._iprot)
4649 
      self._iprot.readMessageEnd()
4650 
      raise x
4651 
    result = saveBluedartSettlements_result()
4652 
    result.read(self._iprot)
4653 
    self._iprot.readMessageEnd()
4654 
    if result.ex is not None:
4655 
      raise result.ex
4656 
    return
4657 
 
4905 varun.gupt 4658 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4659 
    """
4660 
    Parameters:
4661 
     - settlementDate
4662 
     - paymentGatewayId
4905 varun.gupt 4663 
     - referenceId
4600 varun.gupt 4664 
     - serviceTax
4665 
     - otherCharges
4666 
     - netCollection
4667 
    """
4905 varun.gupt 4668 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4669 
    self.recv_savePaymentSettlements()
4670 
 
4905 varun.gupt 4671 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4672 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4673 
    args = savePaymentSettlements_args()
4674 
    args.settlementDate = settlementDate
4675 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4676 
    args.referenceId = referenceId
4600 varun.gupt 4677 
    args.serviceTax = serviceTax
4678 
    args.otherCharges = otherCharges
4679 
    args.netCollection = netCollection
4680 
    args.write(self._oprot)
4681 
    self._oprot.writeMessageEnd()
4682 
    self._oprot.trans.flush()
4683 
 
4684 
  def recv_savePaymentSettlements(self, ):
4685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4686 
    if mtype == TMessageType.EXCEPTION:
4687 
      x = TApplicationException()
4688 
      x.read(self._iprot)
4689 
      self._iprot.readMessageEnd()
4690 
      raise x
4691 
    result = savePaymentSettlements_result()
4692 
    result.read(self._iprot)
4693 
    self._iprot.readMessageEnd()
4694 
    if result.ex is not None:
4695 
      raise result.ex
4696 
    return
4697 
 
4698 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4699 
    """
4700 
    Parameters:
4701 
     - settlementId
4702 
     - settlementDate
4703 
     - transactionDateFrom
4704 
     - transactionDateTo
4705 
     - amount
4706 
    """
4707 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4708 
    self.recv_saveEBSSettlementSummary()
4709 
 
4710 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4711 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4712 
    args = saveEBSSettlementSummary_args()
4713 
    args.settlementId = settlementId
4714 
    args.settlementDate = settlementDate
4715 
    args.transactionDateFrom = transactionDateFrom
4716 
    args.transactionDateTo = transactionDateTo
4717 
    args.amount = amount
4718 
    args.write(self._oprot)
4719 
    self._oprot.writeMessageEnd()
4720 
    self._oprot.trans.flush()
4721 
 
4722 
  def recv_saveEBSSettlementSummary(self, ):
4723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4724 
    if mtype == TMessageType.EXCEPTION:
4725 
      x = TApplicationException()
4726 
      x.read(self._iprot)
4727 
      self._iprot.readMessageEnd()
4728 
      raise x
4729 
    result = saveEBSSettlementSummary_result()
4730 
    result.read(self._iprot)
4731 
    self._iprot.readMessageEnd()
4732 
    if result.ex is not None:
4733 
      raise result.ex
4734 
    return
4735 
 
5386 phani.kuma 4736 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4737 
    """
4738 
    Parameters:
5189 varun.gupt 4739 
     - referenceId
4740 
     - isRefund
4600 varun.gupt 4741 
    """
5386 phani.kuma 4742 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4743 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4744 
 
5386 phani.kuma 4745 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4746 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4747 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4748 
    args.referenceId = referenceId
4749 
    args.isRefund = isRefund
4600 varun.gupt 4750 
    args.write(self._oprot)
4751 
    self._oprot.writeMessageEnd()
4752 
    self._oprot.trans.flush()
4753 
 
5386 phani.kuma 4754 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4756 
    if mtype == TMessageType.EXCEPTION:
4757 
      x = TApplicationException()
4758 
      x.read(self._iprot)
4759 
      self._iprot.readMessageEnd()
4760 
      raise x
5386 phani.kuma 4761 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4762 
    result.read(self._iprot)
4763 
    self._iprot.readMessageEnd()
4764 
    if result.success is not None:
4765 
      return result.success
4766 
    if result.ex is not None:
4767 
      raise result.ex
5386 phani.kuma 4768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4769 
 
5386 phani.kuma 4770 
  def getSettlementForCod(self, orderId, isRefund):
4771 
    """
4772 
    Parameters:
4773 
     - orderId
4774 
     - isRefund
4775 
    """
4776 
    self.send_getSettlementForCod(orderId, isRefund)
4777 
    return self.recv_getSettlementForCod()
4778 
 
4779 
  def send_getSettlementForCod(self, orderId, isRefund):
4780 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4781 
    args = getSettlementForCod_args()
4782 
    args.orderId = orderId
4783 
    args.isRefund = isRefund
4784 
    args.write(self._oprot)
4785 
    self._oprot.writeMessageEnd()
4786 
    self._oprot.trans.flush()
4787 
 
4788 
  def recv_getSettlementForCod(self, ):
4789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4790 
    if mtype == TMessageType.EXCEPTION:
4791 
      x = TApplicationException()
4792 
      x.read(self._iprot)
4793 
      self._iprot.readMessageEnd()
4794 
      raise x
4795 
    result = getSettlementForCod_result()
4796 
    result.read(self._iprot)
4797 
    self._iprot.readMessageEnd()
4798 
    if result.success is not None:
4799 
      return result.success
4800 
    if result.ex is not None:
4801 
      raise result.ex
4802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4803 
 
4600 varun.gupt 4804 
  def getEBSSettlementSummaries(self, ):
4805 
    self.send_getEBSSettlementSummaries()
4806 
    return self.recv_getEBSSettlementSummaries()
4807 
 
4808 
  def send_getEBSSettlementSummaries(self, ):
4809 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4810 
    args = getEBSSettlementSummaries_args()
4811 
    args.write(self._oprot)
4812 
    self._oprot.writeMessageEnd()
4813 
    self._oprot.trans.flush()
4814 
 
4815 
  def recv_getEBSSettlementSummaries(self, ):
4816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4817 
    if mtype == TMessageType.EXCEPTION:
4818 
      x = TApplicationException()
4819 
      x.read(self._iprot)
4820 
      self._iprot.readMessageEnd()
4821 
      raise x
4822 
    result = getEBSSettlementSummaries_result()
4823 
    result.read(self._iprot)
4824 
    self._iprot.readMessageEnd()
4825 
    if result.success is not None:
4826 
      return result.success
4827 
    if result.ex is not None:
4828 
      raise result.ex
4829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4830 
 
4831 
  def markEBSSettlementUploaded(self, settlementId):
4832 
    """
4833 
    Parameters:
4834 
     - settlementId
4835 
    """
4836 
    self.send_markEBSSettlementUploaded(settlementId)
4837 
    self.recv_markEBSSettlementUploaded()
4838 
 
4839 
  def send_markEBSSettlementUploaded(self, settlementId):
4840 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4841 
    args = markEBSSettlementUploaded_args()
4842 
    args.settlementId = settlementId
4843 
    args.write(self._oprot)
4844 
    self._oprot.writeMessageEnd()
4845 
    self._oprot.trans.flush()
4846 
 
4847 
  def recv_markEBSSettlementUploaded(self, ):
4848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4849 
    if mtype == TMessageType.EXCEPTION:
4850 
      x = TApplicationException()
4851 
      x.read(self._iprot)
4852 
      self._iprot.readMessageEnd()
4853 
      raise x
4854 
    result = markEBSSettlementUploaded_result()
4855 
    result.read(self._iprot)
4856 
    self._iprot.readMessageEnd()
4857 
    if result.ex is not None:
4858 
      raise result.ex
4859 
    return
4860 
 
4861 
  def getEBSSettlementDate(self, settlementId):
4862 
    """
4863 
    Parameters:
4864 
     - settlementId
4865 
    """
4866 
    self.send_getEBSSettlementDate(settlementId)
4867 
    return self.recv_getEBSSettlementDate()
4868 
 
4869 
  def send_getEBSSettlementDate(self, settlementId):
4870 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4871 
    args = getEBSSettlementDate_args()
4872 
    args.settlementId = settlementId
4873 
    args.write(self._oprot)
4874 
    self._oprot.writeMessageEnd()
4875 
    self._oprot.trans.flush()
4876 
 
4877 
  def recv_getEBSSettlementDate(self, ):
4878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4879 
    if mtype == TMessageType.EXCEPTION:
4880 
      x = TApplicationException()
4881 
      x.read(self._iprot)
4882 
      self._iprot.readMessageEnd()
4883 
      raise x
4884 
    result = getEBSSettlementDate_result()
4885 
    result.read(self._iprot)
4886 
    self._iprot.readMessageEnd()
4887 
    if result.success is not None:
4888 
      return result.success
4889 
    if result.ex is not None:
4890 
      raise result.ex
4891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4892 
 
4715 varun.gupt 4893 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4894 
    """
4895 
    Parameters:
4896 
     - settlementDateFrom
4897 
     - settlementDateTo
4898 
     - isRefund
4899 
    """
4900 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4901 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4902 
 
4715 varun.gupt 4903 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4904 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4905 
    args = getSettlementsByDate_args()
4906 
    args.settlementDateFrom = settlementDateFrom
4907 
    args.settlementDateTo = settlementDateTo
4908 
    args.isRefund = isRefund
4909 
    args.write(self._oprot)
4910 
    self._oprot.writeMessageEnd()
4911 
    self._oprot.trans.flush()
4912 
 
4913 
  def recv_getSettlementsByDate(self, ):
4914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4915 
    if mtype == TMessageType.EXCEPTION:
4916 
      x = TApplicationException()
4917 
      x.read(self._iprot)
4918 
      self._iprot.readMessageEnd()
4919 
      raise x
4920 
    result = getSettlementsByDate_result()
4921 
    result.read(self._iprot)
4922 
    self._iprot.readMessageEnd()
4923 
    if result.success is not None:
4924 
      return result.success
4925 
    if result.ex is not None:
4926 
      raise result.ex
4927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4928 
 
4929 
  def getReshippedOrderIds(self, orderIds):
4930 
    """
4931 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4932 
 
4933 
    Parameters:
4934 
     - orderIds
4935 
    """
4936 
    self.send_getReshippedOrderIds(orderIds)
4937 
    return self.recv_getReshippedOrderIds()
4938 
 
4939 
  def send_getReshippedOrderIds(self, orderIds):
4940 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4941 
    args = getReshippedOrderIds_args()
4942 
    args.orderIds = orderIds
4943 
    args.write(self._oprot)
4944 
    self._oprot.writeMessageEnd()
4945 
    self._oprot.trans.flush()
4946 
 
4947 
  def recv_getReshippedOrderIds(self, ):
4948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4949 
    if mtype == TMessageType.EXCEPTION:
4950 
      x = TApplicationException()
4951 
      x.read(self._iprot)
4952 
      self._iprot.readMessageEnd()
4953 
      raise x
4954 
    result = getReshippedOrderIds_result()
4955 
    result.read(self._iprot)
4956 
    self._iprot.readMessageEnd()
4957 
    if result.success is not None:
4958 
      return result.success
4959 
    if result.ex is not None:
4960 
      raise result.ex
4961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4962 
 
5481 phani.kuma 4963 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 4964 
    """
4965 
    Parameters:
4966 
     - vendorId
5481 phani.kuma 4967 
     - onlyVendorNotPaid
4968 
     - billingDateFrom
4969 
     - billingDateTo
4875 varun.gupt 4970 
    """
5481 phani.kuma 4971 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
4972 
    return self.recv_getBilledOrders()
4757 mandeep.dh 4973 
 
5481 phani.kuma 4974 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4975 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
4976 
    args = getBilledOrders_args()
4875 varun.gupt 4977 
    args.vendorId = vendorId
5481 phani.kuma 4978 
    args.onlyVendorNotPaid = onlyVendorNotPaid
4979 
    args.billingDateFrom = billingDateFrom
4980 
    args.billingDateTo = billingDateTo
4875 varun.gupt 4981 
    args.write(self._oprot)
4982 
    self._oprot.writeMessageEnd()
4983 
    self._oprot.trans.flush()
4984 
 
5481 phani.kuma 4985 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 4986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4987 
    if mtype == TMessageType.EXCEPTION:
4988 
      x = TApplicationException()
4989 
      x.read(self._iprot)
4990 
      self._iprot.readMessageEnd()
4991 
      raise x
5481 phani.kuma 4992 
    result = getBilledOrders_result()
4875 varun.gupt 4993 
    result.read(self._iprot)
4994 
    self._iprot.readMessageEnd()
4995 
    if result.success is not None:
4996 
      return result.success
4997 
    if result.ex is not None:
4998 
      raise result.ex
5481 phani.kuma 4999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5000 
 
5031 varun.gupt 5001 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5002 
    """
5003 
    Parameters:
5004 
     - startDate
5005 
     - endDate
5006 
    """
5007 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5008 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5009 
 
5031 varun.gupt 5010 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5011 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5012 
    args = getStatusDistributionOfOrders_args()
5013 
    args.startDate = startDate
5014 
    args.endDate = endDate
5015 
    args.write(self._oprot)
5016 
    self._oprot.writeMessageEnd()
5017 
    self._oprot.trans.flush()
5018 
 
5019 
  def recv_getStatusDistributionOfOrders(self, ):
5020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5021 
    if mtype == TMessageType.EXCEPTION:
5022 
      x = TApplicationException()
5023 
      x.read(self._iprot)
5024 
      self._iprot.readMessageEnd()
5025 
      raise x
5026 
    result = getStatusDistributionOfOrders_result()
5027 
    result.read(self._iprot)
5028 
    self._iprot.readMessageEnd()
5029 
    if result.success is not None:
5030 
      return result.success
5031 
    if result.ex is not None:
5032 
      raise result.ex
5033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5034 
 
5067 varun.gupt 5035 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5036 
    """
5037 
    Parameters:
5038 
     - status
5039 
     - startDatetime
5040 
     - endDatetime
5041 
    """
5042 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5043 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5044 
 
5067 varun.gupt 5045 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5046 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5047 
    args = getOrderIdsForStatus_args()
5048 
    args.status = status
5049 
    args.startDatetime = startDatetime
5050 
    args.endDatetime = endDatetime
5051 
    args.write(self._oprot)
5052 
    self._oprot.writeMessageEnd()
5053 
    self._oprot.trans.flush()
5054 
 
5055 
  def recv_getOrderIdsForStatus(self, ):
5056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5057 
    if mtype == TMessageType.EXCEPTION:
5058 
      x = TApplicationException()
5059 
      x.read(self._iprot)
5060 
      self._iprot.readMessageEnd()
5061 
      raise x
5062 
    result = getOrderIdsForStatus_result()
5063 
    result.read(self._iprot)
5064 
    self._iprot.readMessageEnd()
5065 
    if result.success is not None:
5066 
      return result.success
5067 
    if result.ex is not None:
5068 
      raise result.ex
5069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5070 
 
5348 anupam.sin 5071 
  def updateCODAgent(self, agent, orderId):
5072 
    """
5073 
    Updates the agent who handled the COD verification call
5074 
 
5075 
    Parameters:
5076 
     - agent
5077 
     - orderId
5078 
    """
5079 
    self.send_updateCODAgent(agent, orderId)
5080 
    self.recv_updateCODAgent()
5081 
 
5082 
  def send_updateCODAgent(self, agent, orderId):
5083 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5084 
    args = updateCODAgent_args()
5085 
    args.agent = agent
5086 
    args.orderId = orderId
5087 
    args.write(self._oprot)
5088 
    self._oprot.writeMessageEnd()
5089 
    self._oprot.trans.flush()
5090 
 
5091 
  def recv_updateCODAgent(self, ):
5092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5093 
    if mtype == TMessageType.EXCEPTION:
5094 
      x = TApplicationException()
5095 
      x.read(self._iprot)
5096 
      self._iprot.readMessageEnd()
5097 
      raise x
5098 
    result = updateCODAgent_result()
5099 
    result.read(self._iprot)
5100 
    self._iprot.readMessageEnd()
5101 
    if result.ex is not None:
5102 
      raise result.ex
5103 
    return
5104 
 
5099 varun.gupt 5105 
  def updateOrderAsPaidToVendor(self, orderId):
5106 
    """
5107 
    Parameters:
5108 
     - orderId
5109 
    """
5110 
    self.send_updateOrderAsPaidToVendor(orderId)
5111 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5112 
 
5099 varun.gupt 5113 
  def send_updateOrderAsPaidToVendor(self, orderId):
5114 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5115 
    args = updateOrderAsPaidToVendor_args()
5116 
    args.orderId = orderId
5117 
    args.write(self._oprot)
5118 
    self._oprot.writeMessageEnd()
5119 
    self._oprot.trans.flush()
5120 
 
5121 
  def recv_updateOrderAsPaidToVendor(self, ):
5122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5123 
    if mtype == TMessageType.EXCEPTION:
5124 
      x = TApplicationException()
5125 
      x.read(self._iprot)
5126 
      self._iprot.readMessageEnd()
5127 
      raise x
5128 
    result = updateOrderAsPaidToVendor_result()
5129 
    result.read(self._iprot)
5130 
    self._iprot.readMessageEnd()
5131 
    if result.ex is not None:
5132 
      raise result.ex
5133 
    return
5134 
 
5386 phani.kuma 5135 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5136 
    """
5137 
    Parameters:
5138 
     - orderId
5139 
    """
5140 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5141 
    self.recv_updateOrderOnlyAsPaidToVendor()
5142 
 
5143 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5144 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5145 
    args = updateOrderOnlyAsPaidToVendor_args()
5146 
    args.orderId = orderId
5147 
    args.write(self._oprot)
5148 
    self._oprot.writeMessageEnd()
5149 
    self._oprot.trans.flush()
5150 
 
5151 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5153 
    if mtype == TMessageType.EXCEPTION:
5154 
      x = TApplicationException()
5155 
      x.read(self._iprot)
5156 
      self._iprot.readMessageEnd()
5157 
      raise x
5158 
    result = updateOrderOnlyAsPaidToVendor_result()
5159 
    result.read(self._iprot)
5160 
    self._iprot.readMessageEnd()
5161 
    if result.ex is not None:
5162 
      raise result.ex
5163 
    return
5164 
 
5208 varun.gupt 5165 
  def getRefundedOrdersMarkedPaid(self, ):
5166 
    self.send_getRefundedOrdersMarkedPaid()
5167 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5168 
 
5208 varun.gupt 5169 
  def send_getRefundedOrdersMarkedPaid(self, ):
5170 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5171 
    args = getRefundedOrdersMarkedPaid_args()
5172 
    args.write(self._oprot)
5173 
    self._oprot.writeMessageEnd()
5174 
    self._oprot.trans.flush()
5175 
 
5176 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5178 
    if mtype == TMessageType.EXCEPTION:
5179 
      x = TApplicationException()
5180 
      x.read(self._iprot)
5181 
      self._iprot.readMessageEnd()
5182 
      raise x
5183 
    result = getRefundedOrdersMarkedPaid_result()
5184 
    result.read(self._iprot)
5185 
    self._iprot.readMessageEnd()
5186 
    if result.success is not None:
5187 
      return result.success
5188 
    if result.ex is not None:
5189 
      raise result.ex
5190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5191 
 
5447 anupam.sin 5192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5193 
    """
5194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5195 
 
5447 anupam.sin 5196 
 
5197 
    Parameters:
5198 
     - minOrderId
5199 
     - maxOrderId
5200 
    """
5201 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5202 
    return self.recv_getAllVerificationAgents()
5203 
 
5204 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5205 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5206 
    args = getAllVerificationAgents_args()
5207 
    args.minOrderId = minOrderId
5208 
    args.maxOrderId = maxOrderId
5209 
    args.write(self._oprot)
5210 
    self._oprot.writeMessageEnd()
5211 
    self._oprot.trans.flush()
5212 
 
5213 
  def recv_getAllVerificationAgents(self, ):
5214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5215 
    if mtype == TMessageType.EXCEPTION:
5216 
      x = TApplicationException()
5217 
      x.read(self._iprot)
5218 
      self._iprot.readMessageEnd()
5219 
      raise x
5220 
    result = getAllVerificationAgents_result()
5221 
    result.read(self._iprot)
5222 
    self._iprot.readMessageEnd()
5223 
    if result.success is not None:
5224 
      return result.success
5225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5226 
 
5227 
 
3376 rajveer 5228 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5229 
  def __init__(self, handler):
3376 rajveer 5230 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5231 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5232 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5233 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5234 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5235 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5236 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5237 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5238 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5239 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5240 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5241 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5242 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5243 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5244 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5245 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5246 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5247 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5248 
    self._processMap["createOrder"] = Processor.process_createOrder
5249 
    self._processMap["getOrder"] = Processor.process_getOrder
5250 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5251 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5252 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5253 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5254 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5255 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5256 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5257 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5258 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5259 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5260 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5261 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5262 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5263 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5264 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5265 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5266 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5267 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5268 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5269 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5270 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5271 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5272 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5273 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5274 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5275 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5276 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5277 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5278 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5279 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5280 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5281 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5282 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5283 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5284 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5285 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5286 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5287 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5288 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5289 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5290 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5291 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5292 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5293 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5294 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5295 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5296 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5297 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5298 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5299 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5300 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5301 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5302 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5303 
    self._processMap["changeItem"] = Processor.process_changeItem
5304 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5305 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5306 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5307 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5308 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5309 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5310 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5311 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5312 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5313 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5314 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5315 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5316 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5317 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5318 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5319 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5320 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5321 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5322 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5323 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5324 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5325 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5326 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5327 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5328 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5329 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5330 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5331 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5332 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5333 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5334 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5335 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5336 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5337 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5338 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5339 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5340 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5341 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5342 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5343 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5344 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5345 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
94 ashish 5346 
 
5347 
  def process(self, iprot, oprot):
5348 
    (name, type, seqid) = iprot.readMessageBegin()
5349 
    if name not in self._processMap:
5350 
      iprot.skip(TType.STRUCT)
5351 
      iprot.readMessageEnd()
5352 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5353 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5354 
      x.write(oprot)
5355 
      oprot.writeMessageEnd()
5356 
      oprot.trans.flush()
5357 
      return
5358 
    else:
5359 
      self._processMap[name](self, seqid, iprot, oprot)
5360 
    return True
5361 
 
5362 
  def process_createTransaction(self, seqid, iprot, oprot):
5363 
    args = createTransaction_args()
5364 
    args.read(iprot)
5365 
    iprot.readMessageEnd()
5366 
    result = createTransaction_result()
5367 
    try:
132 ashish 5368 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5369 
    except TransactionServiceException, ex:
5370 
      result.ex = ex
5371 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5372 
    result.write(oprot)
5373 
    oprot.writeMessageEnd()
5374 
    oprot.trans.flush()
5375 
 
5376 
  def process_getTransaction(self, seqid, iprot, oprot):
5377 
    args = getTransaction_args()
5378 
    args.read(iprot)
5379 
    iprot.readMessageEnd()
5380 
    result = getTransaction_result()
5381 
    try:
5382 
      result.success = self._handler.getTransaction(args.id)
5383 
    except TransactionServiceException, ex:
5384 
      result.ex = ex
5385 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5386 
    result.write(oprot)
5387 
    oprot.writeMessageEnd()
5388 
    oprot.trans.flush()
5389 
 
5390 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5391 
    args = getTransactionsForCustomer_args()
5392 
    args.read(iprot)
5393 
    iprot.readMessageEnd()
5394 
    result = getTransactionsForCustomer_result()
5395 
    try:
5396 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5397 
    except TransactionServiceException, ex:
5398 
      result.ex = ex
5399 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5400 
    result.write(oprot)
5401 
    oprot.writeMessageEnd()
5402 
    oprot.trans.flush()
5403 
 
132 ashish 5404 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5405 
    args = getTransactionsForShoppingCartId_args()
5406 
    args.read(iprot)
5407 
    iprot.readMessageEnd()
5408 
    result = getTransactionsForShoppingCartId_result()
5409 
    try:
5410 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5411 
    except TransactionServiceException, ex:
5412 
      result.ex = ex
5413 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5414 
    result.write(oprot)
5415 
    oprot.writeMessageEnd()
5416 
    oprot.trans.flush()
5417 
 
94 ashish 5418 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5419 
    args = getTransactionStatus_args()
5420 
    args.read(iprot)
5421 
    iprot.readMessageEnd()
5422 
    result = getTransactionStatus_result()
5423 
    try:
5424 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5425 
    except TransactionServiceException, ex:
5426 
      result.ex = ex
5427 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5428 
    result.write(oprot)
5429 
    oprot.writeMessageEnd()
5430 
    oprot.trans.flush()
5431 
 
5432 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5433 
    args = changeTransactionStatus_args()
5434 
    args.read(iprot)
5435 
    iprot.readMessageEnd()
5436 
    result = changeTransactionStatus_result()
5437 
    try:
5387 rajveer 5438 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.selfPickup)
94 ashish 5439 
    except TransactionServiceException, ex:
5440 
      result.ex = ex
5441 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5442 
    result.write(oprot)
5443 
    oprot.writeMessageEnd()
5444 
    oprot.trans.flush()
5445 
 
1398 varun.gupt 5446 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5447 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5448 
    args.read(iprot)
5449 
    iprot.readMessageEnd()
1398 varun.gupt 5450 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5451 
    try:
1398 varun.gupt 5452 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5453 
    except TransactionServiceException, ex:
5454 
      result.ex = ex
1398 varun.gupt 5455 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5456 
    result.write(oprot)
5457 
    oprot.writeMessageEnd()
5458 
    oprot.trans.flush()
5459 
 
483 rajveer 5460 
  def process_getAllOrders(self, seqid, iprot, oprot):
5461 
    args = getAllOrders_args()
94 ashish 5462 
    args.read(iprot)
5463 
    iprot.readMessageEnd()
483 rajveer 5464 
    result = getAllOrders_result()
94 ashish 5465 
    try:
4801 anupam.sin 5466 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5467 
    except TransactionServiceException, ex:
5468 
      result.ex = ex
483 rajveer 5469 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5470 
    result.write(oprot)
5471 
    oprot.writeMessageEnd()
5472 
    oprot.trans.flush()
5473 
 
4133 chandransh 5474 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5475 
    args = getOrdersInBatch_args()
5476 
    args.read(iprot)
5477 
    iprot.readMessageEnd()
5478 
    result = getOrdersInBatch_result()
5479 
    try:
5480 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5481 
    except TransactionServiceException, ex:
5482 
      result.ex = ex
5483 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5484 
    result.write(oprot)
5485 
    oprot.writeMessageEnd()
5486 
    oprot.trans.flush()
5487 
 
5488 
  def process_getOrderCount(self, seqid, iprot, oprot):
5489 
    args = getOrderCount_args()
5490 
    args.read(iprot)
5491 
    iprot.readMessageEnd()
5492 
    result = getOrderCount_result()
5493 
    try:
5494 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5495 
    except TransactionServiceException, ex:
5496 
      result.ex = ex
5497 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5498 
    result.write(oprot)
5499 
    oprot.writeMessageEnd()
5500 
    oprot.trans.flush()
5501 
 
999 varun.gupt 5502 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5503 
    args = getOrdersByBillingDate_args()
5504 
    args.read(iprot)
5505 
    iprot.readMessageEnd()
5506 
    result = getOrdersByBillingDate_result()
5507 
    try:
5508 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5509 
    except TransactionServiceException, ex:
5510 
      result.ex = ex
5511 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5512 
    result.write(oprot)
5513 
    oprot.writeMessageEnd()
5514 
    oprot.trans.flush()
5515 
 
3427 chandransh 5516 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5517 
    args = getOrdersByShippingDate_args()
5518 
    args.read(iprot)
5519 
    iprot.readMessageEnd()
5520 
    result = getOrdersByShippingDate_result()
5521 
    try:
3451 chandransh 5522 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5523 
    except TransactionServiceException, ex:
5524 
      result.ex = ex
5525 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5526 
    result.write(oprot)
5527 
    oprot.writeMessageEnd()
5528 
    oprot.trans.flush()
5529 
 
1382 varun.gupt 5530 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5531 
    args = getReturnableOrdersForCustomer_args()
5532 
    args.read(iprot)
5533 
    iprot.readMessageEnd()
5534 
    result = getReturnableOrdersForCustomer_result()
5535 
    try:
5536 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5537 
    except TransactionServiceException, ex:
5538 
      result.ex = ex
5539 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5540 
    result.write(oprot)
5541 
    oprot.writeMessageEnd()
5542 
    oprot.trans.flush()
5543 
 
5544 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5545 
    args = getCancellableOrdersForCustomer_args()
5546 
    args.read(iprot)
5547 
    iprot.readMessageEnd()
5548 
    result = getCancellableOrdersForCustomer_result()
5549 
    try:
5550 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5551 
    except TransactionServiceException, ex:
5552 
      result.ex = ex
5553 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5554 
    result.write(oprot)
5555 
    oprot.writeMessageEnd()
5556 
    oprot.trans.flush()
5557 
 
483 rajveer 5558 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5559 
    args = changeOrderStatus_args()
94 ashish 5560 
    args.read(iprot)
5561 
    iprot.readMessageEnd()
483 rajveer 5562 
    result = changeOrderStatus_result()
94 ashish 5563 
    try:
483 rajveer 5564 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5565 
    except TransactionServiceException, ex:
5566 
      result.ex = ex
483 rajveer 5567 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5568 
    result.write(oprot)
5569 
    oprot.writeMessageEnd()
5570 
    oprot.trans.flush()
5571 
 
483 rajveer 5572 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5573 
    args = getOrdersForTransaction_args()
94 ashish 5574 
    args.read(iprot)
5575 
    iprot.readMessageEnd()
483 rajveer 5576 
    result = getOrdersForTransaction_result()
94 ashish 5577 
    try:
1528 ankur.sing 5578 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5579 
    except TransactionServiceException, ex:
5580 
      result.ex = ex
483 rajveer 5581 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5582 
    result.write(oprot)
5583 
    oprot.writeMessageEnd()
5584 
    oprot.trans.flush()
5585 
 
483 rajveer 5586 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5587 
    args = getOrdersForCustomer_args()
94 ashish 5588 
    args.read(iprot)
5589 
    iprot.readMessageEnd()
483 rajveer 5590 
    result = getOrdersForCustomer_result()
94 ashish 5591 
    try:
3014 chandransh 5592 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5593 
    except TransactionServiceException, ex:
5594 
      result.ex = ex
483 rajveer 5595 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5596 
    result.write(oprot)
5597 
    oprot.writeMessageEnd()
5598 
    oprot.trans.flush()
5599 
 
483 rajveer 5600 
  def process_createOrder(self, seqid, iprot, oprot):
5601 
    args = createOrder_args()
94 ashish 5602 
    args.read(iprot)
5603 
    iprot.readMessageEnd()
483 rajveer 5604 
    result = createOrder_result()
94 ashish 5605 
    try:
483 rajveer 5606 
      result.success = self._handler.createOrder(args.order)
94 ashish 5607 
    except TransactionServiceException, ex:
5608 
      result.ex = ex
483 rajveer 5609 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5610 
    result.write(oprot)
5611 
    oprot.writeMessageEnd()
5612 
    oprot.trans.flush()
5613 
 
483 rajveer 5614 
  def process_getOrder(self, seqid, iprot, oprot):
5615 
    args = getOrder_args()
94 ashish 5616 
    args.read(iprot)
5617 
    iprot.readMessageEnd()
483 rajveer 5618 
    result = getOrder_result()
94 ashish 5619 
    try:
483 rajveer 5620 
      result.success = self._handler.getOrder(args.id)
94 ashish 5621 
    except TransactionServiceException, ex:
5622 
      result.ex = ex
483 rajveer 5623 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5624 
    result.write(oprot)
5625 
    oprot.writeMessageEnd()
5626 
    oprot.trans.flush()
5627 
 
483 rajveer 5628 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5629 
    args = getLineItemsForOrder_args()
94 ashish 5630 
    args.read(iprot)
5631 
    iprot.readMessageEnd()
483 rajveer 5632 
    result = getLineItemsForOrder_result()
94 ashish 5633 
    try:
483 rajveer 5634 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5635 
    except TransactionServiceException, ex:
5636 
      result.ex = ex
483 rajveer 5637 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5638 
    result.write(oprot)
5639 
    oprot.writeMessageEnd()
5640 
    oprot.trans.flush()
5641 
 
4999 phani.kuma 5642 
  def process_getOrderList(self, seqid, iprot, oprot):
5643 
    args = getOrderList_args()
5644 
    args.read(iprot)
5645 
    iprot.readMessageEnd()
5646 
    result = getOrderList_result()
5647 
    result.success = self._handler.getOrderList(args.order_ids)
5648 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5649 
    result.write(oprot)
5650 
    oprot.writeMessageEnd()
5651 
    oprot.trans.flush()
5652 
 
5386 phani.kuma 5653 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5654 
    args = getOrderListForVendor_args()
5655 
    args.read(iprot)
5656 
    iprot.readMessageEnd()
5657 
    result = getOrderListForVendor_result()
5658 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5659 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5660 
    result.write(oprot)
5661 
    oprot.writeMessageEnd()
5662 
    oprot.trans.flush()
5663 
 
1528 ankur.sing 5664 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5665 
    args = getOrderForCustomer_args()
5666 
    args.read(iprot)
5667 
    iprot.readMessageEnd()
5668 
    result = getOrderForCustomer_result()
5669 
    try:
5670 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5671 
    except TransactionServiceException, ex:
5672 
      result.ex = ex
5673 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5674 
    result.write(oprot)
5675 
    oprot.writeMessageEnd()
5676 
    oprot.trans.flush()
5677 
 
3064 chandransh 5678 
  def process_getAlerts(self, seqid, iprot, oprot):
5679 
    args = getAlerts_args()
5680 
    args.read(iprot)
5681 
    iprot.readMessageEnd()
5682 
    result = getAlerts_result()
4444 rajveer 5683 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5684 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5685 
    result.write(oprot)
5686 
    oprot.writeMessageEnd()
5687 
    oprot.trans.flush()
5688 
 
4394 rajveer 5689 
  def process_addAlert(self, seqid, iprot, oprot):
5690 
    args = addAlert_args()
3064 chandransh 5691 
    args.read(iprot)
5692 
    iprot.readMessageEnd()
4394 rajveer 5693 
    result = addAlert_result()
4444 rajveer 5694 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5695 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5696 
    result.write(oprot)
5697 
    oprot.writeMessageEnd()
5698 
    oprot.trans.flush()
5699 
 
4444 rajveer 5700 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5701 
    args = markAlertsAsSeen_args()
5702 
    args.read(iprot)
5703 
    iprot.readMessageEnd()
5704 
    result = markAlertsAsSeen_result()
5705 
    self._handler.markAlertsAsSeen(args.warehouseId)
5706 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5707 
    result.write(oprot)
5708 
    oprot.writeMessageEnd()
5709 
    oprot.trans.flush()
5710 
 
3064 chandransh 5711 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5712 
    args = getValidOrderCount_args()
5713 
    args.read(iprot)
5714 
    iprot.readMessageEnd()
5715 
    result = getValidOrderCount_result()
5716 
    result.success = self._handler.getValidOrderCount()
5717 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5718 
    result.write(oprot)
5719 
    oprot.writeMessageEnd()
5720 
    oprot.trans.flush()
5721 
 
5722 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5723 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5724 
    args.read(iprot)
5725 
    iprot.readMessageEnd()
5726 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5727 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5728 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5729 
    result.write(oprot)
5730 
    oprot.writeMessageEnd()
5731 
    oprot.trans.flush()
5732 
 
5733 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5734 
    args = getValidOrdersAmountRange_args()
5735 
    args.read(iprot)
5736 
    iprot.readMessageEnd()
5737 
    result = getValidOrdersAmountRange_result()
5738 
    result.success = self._handler.getValidOrdersAmountRange()
5739 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5740 
    result.write(oprot)
5741 
    oprot.writeMessageEnd()
5742 
    oprot.trans.flush()
5743 
 
5744 
  def process_getValidOrders(self, seqid, iprot, oprot):
5745 
    args = getValidOrders_args()
5746 
    args.read(iprot)
5747 
    iprot.readMessageEnd()
5748 
    result = getValidOrders_result()
5749 
    result.success = self._handler.getValidOrders(args.limit)
5750 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5751 
    result.write(oprot)
5752 
    oprot.writeMessageEnd()
5753 
    oprot.trans.flush()
5754 
 
1220 chandransh 5755 
  def process_batchOrders(self, seqid, iprot, oprot):
5756 
    args = batchOrders_args()
5757 
    args.read(iprot)
5758 
    iprot.readMessageEnd()
5759 
    result = batchOrders_result()
5760 
    try:
5761 
      result.success = self._handler.batchOrders(args.warehouseId)
5762 
    except TransactionServiceException, ex:
5763 
      result.ex = ex
5764 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5765 
    result.write(oprot)
5766 
    oprot.writeMessageEnd()
5767 
    oprot.trans.flush()
5768 
 
1208 chandransh 5769 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5770 
    args = markOrderAsOutOfStock_args()
5771 
    args.read(iprot)
5772 
    iprot.readMessageEnd()
5773 
    result = markOrderAsOutOfStock_result()
5774 
    try:
5775 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5776 
    except TransactionServiceException, ex:
5777 
      result.ex = ex
5778 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5779 
    result.write(oprot)
5780 
    oprot.writeMessageEnd()
5781 
    oprot.trans.flush()
5782 
 
3064 chandransh 5783 
  def process_verifyOrder(self, seqid, iprot, oprot):
5784 
    args = verifyOrder_args()
759 chandransh 5785 
    args.read(iprot)
5786 
    iprot.readMessageEnd()
3064 chandransh 5787 
    result = verifyOrder_result()
759 chandransh 5788 
    try:
3064 chandransh 5789 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5790 
    except TransactionServiceException, ex:
5791 
      result.ex = ex
3064 chandransh 5792 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5793 
    result.write(oprot)
5794 
    oprot.writeMessageEnd()
5795 
    oprot.trans.flush()
5796 
 
3064 chandransh 5797 
  def process_acceptOrder(self, seqid, iprot, oprot):
5798 
    args = acceptOrder_args()
1113 chandransh 5799 
    args.read(iprot)
5800 
    iprot.readMessageEnd()
3064 chandransh 5801 
    result = acceptOrder_result()
1113 chandransh 5802 
    try:
3064 chandransh 5803 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5804 
    except TransactionServiceException, ex:
5805 
      result.ex = ex
3064 chandransh 5806 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5807 
    result.write(oprot)
5808 
    oprot.writeMessageEnd()
5809 
    oprot.trans.flush()
5810 
 
3064 chandransh 5811 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5812 
    args = addBillingDetails_args()
1135 chandransh 5813 
    args.read(iprot)
5814 
    iprot.readMessageEnd()
3064 chandransh 5815 
    result = addBillingDetails_result()
1135 chandransh 5816 
    try:
5110 mandeep.dh 5817 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 5818 
    except TransactionServiceException, ex:
5819 
      result.ex = ex
3064 chandransh 5820 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5821 
    result.write(oprot)
5822 
    oprot.writeMessageEnd()
5823 
    oprot.trans.flush()
5824 
 
4579 rajveer 5825 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5826 
    args = addInvoiceNumber_args()
5827 
    args.read(iprot)
5828 
    iprot.readMessageEnd()
5829 
    result = addInvoiceNumber_result()
5830 
    try:
4763 rajveer 5831 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5832 
    except TransactionServiceException, ex:
5833 
      result.ex = ex
5834 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5835 
    result.write(oprot)
5836 
    oprot.writeMessageEnd()
5837 
    oprot.trans.flush()
5838 
 
4410 rajveer 5839 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5840 
    args = markOrdersAsShippedFromWarehouse_args()
5841 
    args.read(iprot)
5842 
    iprot.readMessageEnd()
5843 
    result = markOrdersAsShippedFromWarehouse_result()
5844 
    try:
4789 rajveer 5845 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5846 
    except TransactionServiceException, ex:
5847 
      result.ex = ex
5848 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5849 
    result.write(oprot)
5850 
    oprot.writeMessageEnd()
5851 
    oprot.trans.flush()
5852 
 
3064 chandransh 5853 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5854 
    args = markOrdersAsPickedUp_args()
304 ashish 5855 
    args.read(iprot)
5856 
    iprot.readMessageEnd()
3064 chandransh 5857 
    result = markOrdersAsPickedUp_result()
5858 
    try:
4910 phani.kuma 5859 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5860 
    except TransactionServiceException, ex:
5861 
      result.ex = ex
5862 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5863 
    result.write(oprot)
5864 
    oprot.writeMessageEnd()
5865 
    oprot.trans.flush()
94 ashish 5866 
 
4910 phani.kuma 5867 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5868 
    args = getOrdersNotPickedUp_args()
5869 
    args.read(iprot)
5870 
    iprot.readMessageEnd()
5871 
    result = getOrdersNotPickedUp_result()
5872 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5873 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5874 
    result.write(oprot)
5875 
    oprot.writeMessageEnd()
5876 
    oprot.trans.flush()
5877 
 
3064 chandransh 5878 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5879 
    args = markOrdersAsDelivered_args()
304 ashish 5880 
    args.read(iprot)
5881 
    iprot.readMessageEnd()
3064 chandransh 5882 
    result = markOrdersAsDelivered_result()
5883 
    try:
5884 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5885 
    except TransactionServiceException, ex:
5886 
      result.ex = ex
5887 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5888 
    result.write(oprot)
5889 
    oprot.writeMessageEnd()
5890 
    oprot.trans.flush()
5891 
 
4910 phani.kuma 5892 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5893 
    args = markAsRTOrders_args()
1596 ankur.sing 5894 
    args.read(iprot)
5895 
    iprot.readMessageEnd()
4910 phani.kuma 5896 
    result = markAsRTOrders_result()
3064 chandransh 5897 
    try:
4910 phani.kuma 5898 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5899 
    except TransactionServiceException, ex:
5900 
      result.ex = ex
4910 phani.kuma 5901 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5902 
    result.write(oprot)
5903 
    oprot.writeMessageEnd()
5904 
    oprot.trans.flush()
304 ashish 5905 
 
4910 phani.kuma 5906 
  def process_getRTOrders(self, seqid, iprot, oprot):
5907 
    args = getRTOrders_args()
5908 
    args.read(iprot)
5909 
    iprot.readMessageEnd()
5910 
    result = getRTOrders_result()
5911 
    result.success = self._handler.getRTOrders(args.providerId)
5912 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5913 
    result.write(oprot)
5914 
    oprot.writeMessageEnd()
5915 
    oprot.trans.flush()
5916 
 
3064 chandransh 5917 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5918 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5919 
    args.read(iprot)
5920 
    iprot.readMessageEnd()
3064 chandransh 5921 
    result = updateNonDeliveryReason_result()
5922 
    try:
4910 phani.kuma 5923 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5924 
    except TransactionServiceException, ex:
5925 
      result.ex = ex
5926 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5927 
    result.write(oprot)
5928 
    oprot.writeMessageEnd()
5929 
    oprot.trans.flush()
1596 ankur.sing 5930 
 
4910 phani.kuma 5931 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5932 
    args = getNonDeliveredOrdersbyCourier_args()
5933 
    args.read(iprot)
5934 
    iprot.readMessageEnd()
5935 
    result = getNonDeliveredOrdersbyCourier_result()
5936 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5937 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5938 
    result.write(oprot)
5939 
    oprot.writeMessageEnd()
5940 
    oprot.trans.flush()
5941 
 
5942 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5943 
    args = markOrdersAsLocalConnected_args()
5944 
    args.read(iprot)
5945 
    iprot.readMessageEnd()
5946 
    result = markOrdersAsLocalConnected_result()
5947 
    try:
5948 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5949 
    except TransactionServiceException, ex:
5950 
      result.ex = ex
5951 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5952 
    result.write(oprot)
5953 
    oprot.writeMessageEnd()
5954 
    oprot.trans.flush()
5955 
 
5956 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5957 
    args = getOrdersNotLocalConnected_args()
5958 
    args.read(iprot)
5959 
    iprot.readMessageEnd()
5960 
    result = getOrdersNotLocalConnected_result()
5961 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5962 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5963 
    result.write(oprot)
5964 
    oprot.writeMessageEnd()
5965 
    oprot.trans.flush()
5966 
 
5967 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5968 
    args = markOrdersAsDestinationCityReached_args()
5969 
    args.read(iprot)
5970 
    iprot.readMessageEnd()
5971 
    result = markOrdersAsDestinationCityReached_result()
5972 
    try:
5973 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5974 
    except TransactionServiceException, ex:
5975 
      result.ex = ex
5976 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5977 
    result.write(oprot)
5978 
    oprot.writeMessageEnd()
5979 
    oprot.trans.flush()
5980 
 
5981 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5982 
    args = markOrdersAsFirstDeliveryAttempted_args()
5983 
    args.read(iprot)
5984 
    iprot.readMessageEnd()
5985 
    result = markOrdersAsFirstDeliveryAttempted_result()
5986 
    try:
5987 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5988 
    except TransactionServiceException, ex:
5989 
      result.ex = ex
5990 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5991 
    result.write(oprot)
5992 
    oprot.writeMessageEnd()
5993 
    oprot.trans.flush()
5994 
 
3064 chandransh 5995 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5996 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5997 
    args.read(iprot)
5998 
    iprot.readMessageEnd()
3064 chandransh 5999 
    result = getUndeliveredOrders_result()
6000 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6001 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6002 
    result.write(oprot)
6003 
    oprot.writeMessageEnd()
6004 
    oprot.trans.flush()
6005 
 
4783 phani.kuma 6006 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6007 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6008 
    args.read(iprot)
6009 
    iprot.readMessageEnd()
6010 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6011 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6012 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6013 
    result.write(oprot)
6014 
    oprot.writeMessageEnd()
6015 
    oprot.trans.flush()
6016 
 
2536 chandransh 6017 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6018 
    args = toggleDOAFlag_args()
6019 
    args.read(iprot)
6020 
    iprot.readMessageEnd()
6021 
    result = toggleDOAFlag_result()
6022 
    try:
6023 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6024 
    except TransactionServiceException, ex:
6025 
      result.ex = ex
6026 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6027 
    result.write(oprot)
6028 
    oprot.writeMessageEnd()
6029 
    oprot.trans.flush()
1886 ankur.sing 6030 
 
4712 rajveer 6031 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6032 
    args = markOrderAsDelivered_args()
6033 
    args.read(iprot)
6034 
    iprot.readMessageEnd()
6035 
    result = markOrderAsDelivered_result()
6036 
    try:
6037 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6038 
    except TransactionServiceException, ex:
6039 
      result.ex = ex
6040 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6041 
    result.write(oprot)
6042 
    oprot.writeMessageEnd()
6043 
    oprot.trans.flush()
6044 
 
4454 rajveer 6045 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6046 
    args = markOrderDoaRequestReceived_args()
6047 
    args.read(iprot)
6048 
    iprot.readMessageEnd()
6049 
    result = markOrderDoaRequestReceived_result()
6050 
    try:
6051 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6052 
    except TransactionServiceException, ex:
6053 
      result.ex = ex
6054 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6055 
    result.write(oprot)
6056 
    oprot.writeMessageEnd()
6057 
    oprot.trans.flush()
6058 
 
6059 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6060 
    args = markOrderDoaRequestAuthorized_args()
6061 
    args.read(iprot)
6062 
    iprot.readMessageEnd()
6063 
    result = markOrderDoaRequestAuthorized_result()
6064 
    try:
6065 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6066 
    except TransactionServiceException, ex:
6067 
      result.ex = ex
6068 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6069 
    result.write(oprot)
6070 
    oprot.writeMessageEnd()
6071 
    oprot.trans.flush()
6072 
 
4488 rajveer 6073 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6074 
    args = markOrderReturnRequestReceived_args()
6075 
    args.read(iprot)
6076 
    iprot.readMessageEnd()
6077 
    result = markOrderReturnRequestReceived_result()
6078 
    try:
6079 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6080 
    except TransactionServiceException, ex:
6081 
      result.ex = ex
6082 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6083 
    result.write(oprot)
6084 
    oprot.writeMessageEnd()
6085 
    oprot.trans.flush()
6086 
 
6087 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6088 
    args = markOrderReturnRequestAuthorized_args()
6089 
    args.read(iprot)
6090 
    iprot.readMessageEnd()
6091 
    result = markOrderReturnRequestAuthorized_result()
6092 
    try:
6093 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6094 
    except TransactionServiceException, ex:
6095 
      result.ex = ex
6096 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6097 
    result.write(oprot)
6098 
    oprot.writeMessageEnd()
6099 
    oprot.trans.flush()
6100 
 
2536 chandransh 6101 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6102 
    args = requestPickupNumber_args()
6103 
    args.read(iprot)
6104 
    iprot.readMessageEnd()
6105 
    result = requestPickupNumber_result()
6106 
    try:
4579 rajveer 6107 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6108 
    except TransactionServiceException, ex:
6109 
      result.ex = ex
6110 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6111 
    result.write(oprot)
6112 
    oprot.writeMessageEnd()
6113 
    oprot.trans.flush()
6114 
 
6115 
  def process_authorizePickup(self, seqid, iprot, oprot):
6116 
    args = authorizePickup_args()
6117 
    args.read(iprot)
6118 
    iprot.readMessageEnd()
6119 
    result = authorizePickup_result()
6120 
    try:
4602 rajveer 6121 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6122 
    except TransactionServiceException, ex:
6123 
      result.ex = ex
6124 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6125 
    result.write(oprot)
6126 
    oprot.writeMessageEnd()
6127 
    oprot.trans.flush()
6128 
 
2764 chandransh 6129 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6130 
    args = markDoasAsPickedUp_args()
6131 
    args.read(iprot)
6132 
    iprot.readMessageEnd()
6133 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6134 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6135 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6136 
    result.write(oprot)
6137 
    oprot.writeMessageEnd()
6138 
    oprot.trans.flush()
6139 
 
4910 phani.kuma 6140 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6141 
    args = getDoasNotPickedUp_args()
6142 
    args.read(iprot)
6143 
    iprot.readMessageEnd()
6144 
    result = getDoasNotPickedUp_result()
6145 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6146 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6147 
    result.write(oprot)
6148 
    oprot.writeMessageEnd()
6149 
    oprot.trans.flush()
6150 
 
4741 phani.kuma 6151 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6152 
    args = markReturnOrdersAsPickedUp_args()
6153 
    args.read(iprot)
6154 
    iprot.readMessageEnd()
6155 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6156 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6157 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6158 
    result.write(oprot)
6159 
    oprot.writeMessageEnd()
6160 
    oprot.trans.flush()
6161 
 
4910 phani.kuma 6162 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6163 
    args = getReturnOrdersNotPickedUp_args()
6164 
    args.read(iprot)
6165 
    iprot.readMessageEnd()
6166 
    result = getReturnOrdersNotPickedUp_result()
6167 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6168 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6169 
    result.write(oprot)
6170 
    oprot.writeMessageEnd()
6171 
    oprot.trans.flush()
6172 
 
2616 chandransh 6173 
  def process_receiveReturn(self, seqid, iprot, oprot):
6174 
    args = receiveReturn_args()
2591 chandransh 6175 
    args.read(iprot)
6176 
    iprot.readMessageEnd()
2616 chandransh 6177 
    result = receiveReturn_result()
2591 chandransh 6178 
    try:
4479 rajveer 6179 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6180 
    except TransactionServiceException, ex:
6181 
      result.ex = ex
2616 chandransh 6182 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
2536 chandransh 6186 
 
2591 chandransh 6187 
  def process_validateDoa(self, seqid, iprot, oprot):
6188 
    args = validateDoa_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = validateDoa_result()
6192 
    try:
6193 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6194 
    except TransactionServiceException, ex:
6195 
      result.ex = ex
6196 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6197 
    result.write(oprot)
6198 
    oprot.writeMessageEnd()
6199 
    oprot.trans.flush()
6200 
 
4495 rajveer 6201 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6202 
    args = validateReturnProduct_args()
6203 
    args.read(iprot)
6204 
    iprot.readMessageEnd()
6205 
    result = validateReturnProduct_result()
6206 
    try:
6207 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6208 
    except TransactionServiceException, ex:
6209 
      result.ex = ex
6210 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6211 
    result.write(oprot)
6212 
    oprot.writeMessageEnd()
6213 
    oprot.trans.flush()
6214 
 
2616 chandransh 6215 
  def process_reshipOrder(self, seqid, iprot, oprot):
6216 
    args = reshipOrder_args()
6217 
    args.read(iprot)
6218 
    iprot.readMessageEnd()
6219 
    result = reshipOrder_result()
6220 
    try:
6221 
      result.success = self._handler.reshipOrder(args.orderId)
6222 
    except TransactionServiceException, ex:
6223 
      result.ex = ex
6224 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6225 
    result.write(oprot)
6226 
    oprot.writeMessageEnd()
6227 
    oprot.trans.flush()
2591 chandransh 6228 
 
2616 chandransh 6229 
  def process_refundOrder(self, seqid, iprot, oprot):
6230 
    args = refundOrder_args()
6231 
    args.read(iprot)
6232 
    iprot.readMessageEnd()
6233 
    result = refundOrder_result()
6234 
    try:
3226 chandransh 6235 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6236 
    except TransactionServiceException, ex:
6237 
      result.ex = ex
6238 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6239 
    result.write(oprot)
6240 
    oprot.writeMessageEnd()
6241 
    oprot.trans.flush()
6242 
 
2690 chandransh 6243 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6244 
    args = getReturnOrders_args()
6245 
    args.read(iprot)
6246 
    iprot.readMessageEnd()
6247 
    result = getReturnOrders_result()
6248 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6249 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6250 
    result.write(oprot)
6251 
    oprot.writeMessageEnd()
6252 
    oprot.trans.flush()
2616 chandransh 6253 
 
5481 phani.kuma 6254 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6255 
    args = getAllReturnOrders_args()
6256 
    args.read(iprot)
6257 
    iprot.readMessageEnd()
6258 
    result = getAllReturnOrders_result()
6259 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6260 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6261 
    result.write(oprot)
6262 
    oprot.writeMessageEnd()
6263 
    oprot.trans.flush()
6264 
 
2700 chandransh 6265 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6266 
    args = getReturnOrder_args()
6267 
    args.read(iprot)
6268 
    iprot.readMessageEnd()
6269 
    result = getReturnOrder_result()
6270 
    try:
6271 
      result.success = self._handler.getReturnOrder(args.id)
6272 
    except TransactionServiceException, ex:
6273 
      result.ex = ex
6274 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6275 
    result.write(oprot)
6276 
    oprot.writeMessageEnd()
6277 
    oprot.trans.flush()
6278 
 
2690 chandransh 6279 
  def process_processReturn(self, seqid, iprot, oprot):
6280 
    args = processReturn_args()
6281 
    args.read(iprot)
6282 
    iprot.readMessageEnd()
6283 
    result = processReturn_result()
6284 
    try:
6285 
      self._handler.processReturn(args.returnOrderId)
6286 
    except TransactionServiceException, ex:
6287 
      result.ex = ex
6288 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6289 
    result.write(oprot)
6290 
    oprot.writeMessageEnd()
6291 
    oprot.trans.flush()
6292 
 
3451 chandransh 6293 
  def process_updateWeight(self, seqid, iprot, oprot):
6294 
    args = updateWeight_args()
6295 
    args.read(iprot)
6296 
    iprot.readMessageEnd()
6297 
    result = updateWeight_result()
6298 
    try:
6299 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6300 
    except TransactionServiceException, ex:
6301 
      result.ex = ex
6302 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6303 
    result.write(oprot)
6304 
    oprot.writeMessageEnd()
6305 
    oprot.trans.flush()
2819 chandransh 6306 
 
3469 chandransh 6307 
  def process_changeItem(self, seqid, iprot, oprot):
6308 
    args = changeItem_args()
6309 
    args.read(iprot)
6310 
    iprot.readMessageEnd()
6311 
    result = changeItem_result()
6312 
    try:
6313 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6314 
    except TransactionServiceException, ex:
6315 
      result.ex = ex
6316 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
3451 chandransh 6320 
 
3469 chandransh 6321 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6322 
    args = shiftToWarehouse_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = shiftToWarehouse_result()
6326 
    try:
6327 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6328 
    except TransactionServiceException, ex:
6329 
      result.ex = ex
6330 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6331 
    result.write(oprot)
6332 
    oprot.writeMessageEnd()
6333 
    oprot.trans.flush()
6334 
 
3553 chandransh 6335 
  def process_addDelayReason(self, seqid, iprot, oprot):
6336 
    args = addDelayReason_args()
6337 
    args.read(iprot)
6338 
    iprot.readMessageEnd()
6339 
    result = addDelayReason_result()
6340 
    try:
4647 rajveer 6341 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6342 
    except TransactionServiceException, ex:
6343 
      result.ex = ex
6344 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6345 
    result.write(oprot)
6346 
    oprot.writeMessageEnd()
6347 
    oprot.trans.flush()
3469 chandransh 6348 
 
3956 chandransh 6349 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6350 
    args = reconcileCodCollection_args()
6351 
    args.read(iprot)
6352 
    iprot.readMessageEnd()
6353 
    result = reconcileCodCollection_result()
6354 
    try:
6355 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6356 
    except TransactionServiceException, ex:
6357 
      result.ex = ex
6358 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6359 
    result.write(oprot)
6360 
    oprot.writeMessageEnd()
6361 
    oprot.trans.flush()
3553 chandransh 6362 
 
4008 mandeep.dh 6363 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6364 
    args = getTransactionsRequiringExtraProcessing_args()
6365 
    args.read(iprot)
6366 
    iprot.readMessageEnd()
6367 
    result = getTransactionsRequiringExtraProcessing_result()
6368 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6369 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6370 
    result.write(oprot)
6371 
    oprot.writeMessageEnd()
6372 
    oprot.trans.flush()
3956 chandransh 6373 
 
4008 mandeep.dh 6374 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6375 
    args = markTransactionAsProcessed_args()
6376 
    args.read(iprot)
6377 
    iprot.readMessageEnd()
6378 
    result = markTransactionAsProcessed_result()
6379 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6380 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6381 
    result.write(oprot)
6382 
    oprot.writeMessageEnd()
6383 
    oprot.trans.flush()
6384 
 
4018 chandransh 6385 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6386 
    args = getItemWiseRiskyOrdersCount_args()
6387 
    args.read(iprot)
6388 
    iprot.readMessageEnd()
6389 
    result = getItemWiseRiskyOrdersCount_result()
6390 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6391 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6392 
    result.write(oprot)
6393 
    oprot.writeMessageEnd()
6394 
    oprot.trans.flush()
4008 mandeep.dh 6395 
 
4295 varun.gupt 6396 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6397 
    args = getOrdersForItemIds_args()
6398 
    args.read(iprot)
6399 
    iprot.readMessageEnd()
6400 
    result = getOrdersForItemIds_result()
6401 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6402 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6403 
    result.write(oprot)
6404 
    oprot.writeMessageEnd()
6405 
    oprot.trans.flush()
6406 
 
4247 rajveer 6407 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6408 
    args = markOrderCancellationRequestReceived_args()
6409 
    args.read(iprot)
6410 
    iprot.readMessageEnd()
6411 
    result = markOrderCancellationRequestReceived_result()
6412 
    try:
6413 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6414 
    except TransactionServiceException, ex:
6415 
      result.ex = ex
6416 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6417 
    result.write(oprot)
6418 
    oprot.writeMessageEnd()
6419 
    oprot.trans.flush()
4018 chandransh 6420 
 
4247 rajveer 6421 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6422 
    args = markOrderCancellationRequestConfirmed_args()
6423 
    args.read(iprot)
6424 
    iprot.readMessageEnd()
6425 
    result = markOrderCancellationRequestConfirmed_result()
6426 
    try:
6427 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6428 
    except TransactionServiceException, ex:
6429 
      result.ex = ex
6430 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6431 
    result.write(oprot)
6432 
    oprot.writeMessageEnd()
6433 
    oprot.trans.flush()
6434 
 
6435 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6436 
    args = markOrderCancellationRequestDenied_args()
6437 
    args.read(iprot)
6438 
    iprot.readMessageEnd()
6439 
    result = markOrderCancellationRequestDenied_result()
6440 
    try:
6441 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6442 
    except TransactionServiceException, ex:
6443 
      result.ex = ex
6444 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6445 
    result.write(oprot)
6446 
    oprot.writeMessageEnd()
6447 
    oprot.trans.flush()
6448 
 
4258 rajveer 6449 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6450 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6451 
    args.read(iprot)
6452 
    iprot.readMessageEnd()
4258 rajveer 6453 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6454 
    try:
4258 rajveer 6455 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6456 
    except TransactionServiceException, ex:
6457 
      result.ex = ex
4258 rajveer 6458 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6459 
    result.write(oprot)
6460 
    oprot.writeMessageEnd()
6461 
    oprot.trans.flush()
6462 
 
4259 anupam.sin 6463 
  def process_refundTransaction(self, seqid, iprot, oprot):
6464 
    args = refundTransaction_args()
6465 
    args.read(iprot)
6466 
    iprot.readMessageEnd()
6467 
    result = refundTransaction_result()
6468 
    try:
6469 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6470 
    except TransactionServiceException, ex:
6471 
      result.ex = ex
6472 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6473 
    result.write(oprot)
6474 
    oprot.writeMessageEnd()
6475 
    oprot.trans.flush()
4247 rajveer 6476 
 
4324 mandeep.dh 6477 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6478 
    args = updateShipmentAddress_args()
6479 
    args.read(iprot)
6480 
    iprot.readMessageEnd()
6481 
    result = updateShipmentAddress_result()
6482 
    try:
6483 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6484 
    except TransactionServiceException, ex:
6485 
      result.ex = ex
6486 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6487 
    result.write(oprot)
6488 
    oprot.writeMessageEnd()
6489 
    oprot.trans.flush()
6490 
 
4285 rajveer 6491 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6492 
    args = acceptOrdersForItemId_args()
6493 
    args.read(iprot)
6494 
    iprot.readMessageEnd()
6495 
    result = acceptOrdersForItemId_result()
6496 
    try:
6497 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6498 
    except TransactionServiceException, ex:
6499 
      result.ex = ex
6500 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6501 
    result.write(oprot)
6502 
    oprot.writeMessageEnd()
6503 
    oprot.trans.flush()
4259 anupam.sin 6504 
 
4303 rajveer 6505 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6506 
    args = markOrdersAsPORaised_args()
6507 
    args.read(iprot)
6508 
    iprot.readMessageEnd()
6509 
    result = markOrdersAsPORaised_result()
6510 
    try:
4369 rajveer 6511 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6512 
    except TransactionServiceException, ex:
6513 
      result.ex = ex
6514 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6515 
    result.write(oprot)
6516 
    oprot.writeMessageEnd()
6517 
    oprot.trans.flush()
4285 rajveer 6518 
 
4303 rajveer 6519 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6520 
    args = markOrdersAsReversalInitiated_args()
6521 
    args.read(iprot)
6522 
    iprot.readMessageEnd()
6523 
    result = markOrdersAsReversalInitiated_result()
6524 
    try:
4369 rajveer 6525 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6526 
    except TransactionServiceException, ex:
6527 
      result.ex = ex
6528 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6529 
    result.write(oprot)
6530 
    oprot.writeMessageEnd()
6531 
    oprot.trans.flush()
6532 
 
6533 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6534 
    args = markOrdersAsNotAvailabke_args()
6535 
    args.read(iprot)
6536 
    iprot.readMessageEnd()
6537 
    result = markOrdersAsNotAvailabke_result()
6538 
    try:
4369 rajveer 6539 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6540 
    except TransactionServiceException, ex:
6541 
      result.ex = ex
6542 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6543 
    result.write(oprot)
6544 
    oprot.writeMessageEnd()
6545 
    oprot.trans.flush()
6546 
 
4369 rajveer 6547 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6548 
    args = markOrdersAsTimeout_args()
6549 
    args.read(iprot)
6550 
    iprot.readMessageEnd()
6551 
    result = markOrdersAsTimeout_result()
6552 
    try:
6553 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6554 
    except TransactionServiceException, ex:
6555 
      result.ex = ex
6556 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6557 
    result.write(oprot)
6558 
    oprot.writeMessageEnd()
6559 
    oprot.trans.flush()
4303 rajveer 6560 
 
4662 rajveer 6561 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6562 
    args = markOrderAsLostInTransit_args()
6563 
    args.read(iprot)
6564 
    iprot.readMessageEnd()
6565 
    result = markOrderAsLostInTransit_result()
6566 
    try:
6567 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6568 
    except TransactionServiceException, ex:
6569 
      result.ex = ex
6570 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6571 
    result.write(oprot)
6572 
    oprot.writeMessageEnd()
6573 
    oprot.trans.flush()
6574 
 
4386 anupam.sin 6575 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6576 
    args = getOrderForAwb_args()
6577 
    args.read(iprot)
6578 
    iprot.readMessageEnd()
6579 
    result = getOrderForAwb_result()
6580 
    try:
6581 
      result.success = self._handler.getOrderForAwb(args.awb)
6582 
    except TransactionServiceException, ex:
6583 
      result.ex = ex
6584 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6585 
    result.write(oprot)
6586 
    oprot.writeMessageEnd()
6587 
    oprot.trans.flush()
4369 rajveer 6588 
 
4506 phani.kuma 6589 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6590 
    args = getOrdersForProviderForStatus_args()
6591 
    args.read(iprot)
6592 
    iprot.readMessageEnd()
6593 
    result = getOrdersForProviderForStatus_result()
6594 
    try:
4910 phani.kuma 6595 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6596 
    except TransactionServiceException, ex:
6597 
      result.ex = ex
6598 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6599 
    result.write(oprot)
6600 
    oprot.writeMessageEnd()
6601 
    oprot.trans.flush()
4386 anupam.sin 6602 
 
4600 varun.gupt 6603 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6604 
    args = getBilledOrdersForVendor_args()
6605 
    args.read(iprot)
6606 
    iprot.readMessageEnd()
6607 
    result = getBilledOrdersForVendor_result()
6608 
    try:
6609 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6610 
    except TransactionServiceException, ex:
6611 
      result.ex = ex
6612 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6613 
    result.write(oprot)
6614 
    oprot.writeMessageEnd()
6615 
    oprot.trans.flush()
4506 phani.kuma 6616 
 
4607 rajveer 6617 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6618 
    args = getSlippedSippingDateOrders_args()
6619 
    args.read(iprot)
6620 
    iprot.readMessageEnd()
6621 
    result = getSlippedSippingDateOrders_result()
6622 
    try:
6623 
      result.success = self._handler.getSlippedSippingDateOrders()
6624 
    except TransactionServiceException, ex:
6625 
      result.ex = ex
6626 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
4709 rajveer 6631 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6632 
    args = getCancelledOrders_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getCancelledOrders_result()
6636 
    try:
6637 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6638 
    except TransactionServiceException, ex:
6639 
      result.ex = ex
6640 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6641 
    result.write(oprot)
6642 
    oprot.writeMessageEnd()
6643 
    oprot.trans.flush()
6644 
 
4600 varun.gupt 6645 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6646 
    args = saveBluedartSettlements_args()
6647 
    args.read(iprot)
6648 
    iprot.readMessageEnd()
6649 
    result = saveBluedartSettlements_result()
6650 
    try:
6651 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6652 
    except TransactionServiceException, ex:
6653 
      result.ex = ex
6654 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6655 
    result.write(oprot)
6656 
    oprot.writeMessageEnd()
6657 
    oprot.trans.flush()
6658 
 
6659 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6660 
    args = savePaymentSettlements_args()
6661 
    args.read(iprot)
6662 
    iprot.readMessageEnd()
6663 
    result = savePaymentSettlements_result()
6664 
    try:
4905 varun.gupt 6665 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6666 
    except TransactionServiceException, ex:
6667 
      result.ex = ex
6668 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6669 
    result.write(oprot)
6670 
    oprot.writeMessageEnd()
6671 
    oprot.trans.flush()
6672 
 
6673 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6674 
    args = saveEBSSettlementSummary_args()
6675 
    args.read(iprot)
6676 
    iprot.readMessageEnd()
6677 
    result = saveEBSSettlementSummary_result()
6678 
    try:
6679 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6680 
    except TransactionServiceException, ex:
6681 
      result.ex = ex
6682 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6683 
    result.write(oprot)
6684 
    oprot.writeMessageEnd()
6685 
    oprot.trans.flush()
6686 
 
5386 phani.kuma 6687 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6688 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6689 
    args.read(iprot)
6690 
    iprot.readMessageEnd()
5386 phani.kuma 6691 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6692 
    try:
5386 phani.kuma 6693 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6694 
    except TransactionServiceException, ex:
6695 
      result.ex = ex
5386 phani.kuma 6696 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6697 
    result.write(oprot)
6698 
    oprot.writeMessageEnd()
6699 
    oprot.trans.flush()
6700 
 
5386 phani.kuma 6701 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6702 
    args = getSettlementForCod_args()
6703 
    args.read(iprot)
6704 
    iprot.readMessageEnd()
6705 
    result = getSettlementForCod_result()
6706 
    try:
6707 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6708 
    except TransactionServiceException, ex:
6709 
      result.ex = ex
6710 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6711 
    result.write(oprot)
6712 
    oprot.writeMessageEnd()
6713 
    oprot.trans.flush()
6714 
 
4600 varun.gupt 6715 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6716 
    args = getEBSSettlementSummaries_args()
6717 
    args.read(iprot)
6718 
    iprot.readMessageEnd()
6719 
    result = getEBSSettlementSummaries_result()
6720 
    try:
6721 
      result.success = self._handler.getEBSSettlementSummaries()
6722 
    except TransactionServiceException, ex:
6723 
      result.ex = ex
6724 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6725 
    result.write(oprot)
6726 
    oprot.writeMessageEnd()
6727 
    oprot.trans.flush()
6728 
 
6729 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6730 
    args = markEBSSettlementUploaded_args()
6731 
    args.read(iprot)
6732 
    iprot.readMessageEnd()
6733 
    result = markEBSSettlementUploaded_result()
6734 
    try:
6735 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6736 
    except TransactionServiceException, ex:
6737 
      result.ex = ex
6738 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6739 
    result.write(oprot)
6740 
    oprot.writeMessageEnd()
6741 
    oprot.trans.flush()
6742 
 
6743 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6744 
    args = getEBSSettlementDate_args()
6745 
    args.read(iprot)
6746 
    iprot.readMessageEnd()
6747 
    result = getEBSSettlementDate_result()
6748 
    try:
6749 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6750 
    except TransactionServiceException, ex:
6751 
      result.ex = ex
6752 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6753 
    result.write(oprot)
6754 
    oprot.writeMessageEnd()
6755 
    oprot.trans.flush()
6756 
 
4715 varun.gupt 6757 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6758 
    args = getSettlementsByDate_args()
6759 
    args.read(iprot)
6760 
    iprot.readMessageEnd()
6761 
    result = getSettlementsByDate_result()
6762 
    try:
6763 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6764 
    except TransactionServiceException, ex:
6765 
      result.ex = ex
6766 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6767 
    result.write(oprot)
6768 
    oprot.writeMessageEnd()
6769 
    oprot.trans.flush()
4600 varun.gupt 6770 
 
4715 varun.gupt 6771 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6772 
    args = getReshippedOrderIds_args()
6773 
    args.read(iprot)
6774 
    iprot.readMessageEnd()
6775 
    result = getReshippedOrderIds_result()
6776 
    try:
6777 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6778 
    except TransactionServiceException, ex:
6779 
      result.ex = ex
6780 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6781 
    result.write(oprot)
6782 
    oprot.writeMessageEnd()
6783 
    oprot.trans.flush()
6784 
 
5481 phani.kuma 6785 
  def process_getBilledOrders(self, seqid, iprot, oprot):
6786 
    args = getBilledOrders_args()
4875 varun.gupt 6787 
    args.read(iprot)
6788 
    iprot.readMessageEnd()
5481 phani.kuma 6789 
    result = getBilledOrders_result()
4875 varun.gupt 6790 
    try:
5481 phani.kuma 6791 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 6792 
    except TransactionServiceException, ex:
6793 
      result.ex = ex
5481 phani.kuma 6794 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 6795 
    result.write(oprot)
6796 
    oprot.writeMessageEnd()
6797 
    oprot.trans.flush()
4757 mandeep.dh 6798 
 
5031 varun.gupt 6799 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6800 
    args = getStatusDistributionOfOrders_args()
6801 
    args.read(iprot)
6802 
    iprot.readMessageEnd()
6803 
    result = getStatusDistributionOfOrders_result()
6804 
    try:
6805 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6806 
    except TransactionServiceException, ex:
6807 
      result.ex = ex
6808 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6809 
    result.write(oprot)
6810 
    oprot.writeMessageEnd()
6811 
    oprot.trans.flush()
4875 varun.gupt 6812 
 
5067 varun.gupt 6813 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6814 
    args = getOrderIdsForStatus_args()
6815 
    args.read(iprot)
6816 
    iprot.readMessageEnd()
6817 
    result = getOrderIdsForStatus_result()
6818 
    try:
6819 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6820 
    except TransactionServiceException, ex:
6821 
      result.ex = ex
6822 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
5031 varun.gupt 6826 
 
5348 anupam.sin 6827 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6828 
    args = updateCODAgent_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = updateCODAgent_result()
6832 
    try:
6833 
      self._handler.updateCODAgent(args.agent, args.orderId)
6834 
    except TransactionServiceException, ex:
6835 
      result.ex = ex
6836 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6837 
    result.write(oprot)
6838 
    oprot.writeMessageEnd()
6839 
    oprot.trans.flush()
6840 
 
5099 varun.gupt 6841 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6842 
    args = updateOrderAsPaidToVendor_args()
6843 
    args.read(iprot)
6844 
    iprot.readMessageEnd()
6845 
    result = updateOrderAsPaidToVendor_result()
6846 
    try:
6847 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6848 
    except TransactionServiceException, ex:
6849 
      result.ex = ex
6850 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6851 
    result.write(oprot)
6852 
    oprot.writeMessageEnd()
6853 
    oprot.trans.flush()
5067 varun.gupt 6854 
 
5386 phani.kuma 6855 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
6856 
    args = updateOrderOnlyAsPaidToVendor_args()
6857 
    args.read(iprot)
6858 
    iprot.readMessageEnd()
6859 
    result = updateOrderOnlyAsPaidToVendor_result()
6860 
    try:
6861 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
6862 
    except TransactionServiceException, ex:
6863 
      result.ex = ex
6864 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
6865 
    result.write(oprot)
6866 
    oprot.writeMessageEnd()
6867 
    oprot.trans.flush()
6868 
 
5208 varun.gupt 6869 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6870 
    args = getRefundedOrdersMarkedPaid_args()
6871 
    args.read(iprot)
6872 
    iprot.readMessageEnd()
6873 
    result = getRefundedOrdersMarkedPaid_result()
6874 
    try:
6875 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6876 
    except TransactionServiceException, ex:
6877 
      result.ex = ex
6878 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6879 
    result.write(oprot)
6880 
    oprot.writeMessageEnd()
6881 
    oprot.trans.flush()
5099 varun.gupt 6882 
 
5447 anupam.sin 6883 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
6884 
    args = getAllVerificationAgents_args()
6885 
    args.read(iprot)
6886 
    iprot.readMessageEnd()
6887 
    result = getAllVerificationAgents_result()
6888 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
6889 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
6890 
    result.write(oprot)
6891 
    oprot.writeMessageEnd()
6892 
    oprot.trans.flush()
5208 varun.gupt 6893 
 
5447 anupam.sin 6894 
 
94 ashish 6895 
# HELPER FUNCTIONS AND STRUCTURES
6896 
 
6897 
class createTransaction_args:
6898 
  """
6899 
  Attributes:
6900 
   - transaction
6901 
  """
6902 
 
6903 
  thrift_spec = (
6904 
    None, # 0
6905 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6906 
  )
6907 
 
6908 
  def __init__(self, transaction=None,):
6909 
    self.transaction = transaction
6910 
 
6911 
  def read(self, iprot):
6912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6914 
      return
6915 
    iprot.readStructBegin()
6916 
    while True:
6917 
      (fname, ftype, fid) = iprot.readFieldBegin()
6918 
      if ftype == TType.STOP:
6919 
        break
6920 
      if fid == 1:
6921 
        if ftype == TType.STRUCT:
6922 
          self.transaction = Transaction()
6923 
          self.transaction.read(iprot)
6924 
        else:
6925 
          iprot.skip(ftype)
6926 
      else:
6927 
        iprot.skip(ftype)
6928 
      iprot.readFieldEnd()
6929 
    iprot.readStructEnd()
6930 
 
6931 
  def write(self, oprot):
6932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6934 
      return
6935 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6936 
    if self.transaction is not None:
94 ashish 6937 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6938 
      self.transaction.write(oprot)
6939 
      oprot.writeFieldEnd()
6940 
    oprot.writeFieldStop()
6941 
    oprot.writeStructEnd()
6942 
 
3431 rajveer 6943 
  def validate(self):
6944 
    return
6945 
 
6946 
 
94 ashish 6947 
  def __repr__(self):
6948 
    L = ['%s=%r' % (key, value)
6949 
      for key, value in self.__dict__.iteritems()]
6950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6951 
 
6952 
  def __eq__(self, other):
6953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6954 
 
6955 
  def __ne__(self, other):
6956 
    return not (self == other)
6957 
 
6958 
class createTransaction_result:
6959 
  """
6960 
  Attributes:
132 ashish 6961 
   - success
94 ashish 6962 
   - ex
6963 
  """
6964 
 
6965 
  thrift_spec = (
132 ashish 6966 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6968 
  )
6969 
 
132 ashish 6970 
  def __init__(self, success=None, ex=None,):
6971 
    self.success = success
94 ashish 6972 
    self.ex = ex
6973 
 
6974 
  def read(self, iprot):
6975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6977 
      return
6978 
    iprot.readStructBegin()
6979 
    while True:
6980 
      (fname, ftype, fid) = iprot.readFieldBegin()
6981 
      if ftype == TType.STOP:
6982 
        break
132 ashish 6983 
      if fid == 0:
6984 
        if ftype == TType.I64:
6985 
          self.success = iprot.readI64();
6986 
        else:
6987 
          iprot.skip(ftype)
6988 
      elif fid == 1:
94 ashish 6989 
        if ftype == TType.STRUCT:
6990 
          self.ex = TransactionServiceException()
6991 
          self.ex.read(iprot)
6992 
        else:
6993 
          iprot.skip(ftype)
6994 
      else:
6995 
        iprot.skip(ftype)
6996 
      iprot.readFieldEnd()
6997 
    iprot.readStructEnd()
6998 
 
6999 
  def write(self, oprot):
7000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7002 
      return
7003 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7004 
    if self.success is not None:
132 ashish 7005 
      oprot.writeFieldBegin('success', TType.I64, 0)
7006 
      oprot.writeI64(self.success)
7007 
      oprot.writeFieldEnd()
3431 rajveer 7008 
    if self.ex is not None:
94 ashish 7009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7010 
      self.ex.write(oprot)
7011 
      oprot.writeFieldEnd()
7012 
    oprot.writeFieldStop()
7013 
    oprot.writeStructEnd()
7014 
 
3431 rajveer 7015 
  def validate(self):
7016 
    return
7017 
 
7018 
 
94 ashish 7019 
  def __repr__(self):
7020 
    L = ['%s=%r' % (key, value)
7021 
      for key, value in self.__dict__.iteritems()]
7022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7023 
 
7024 
  def __eq__(self, other):
7025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7026 
 
7027 
  def __ne__(self, other):
7028 
    return not (self == other)
7029 
 
7030 
class getTransaction_args:
7031 
  """
7032 
  Attributes:
7033 
   - id
7034 
  """
7035 
 
7036 
  thrift_spec = (
7037 
    None, # 0
7038 
    (1, TType.I64, 'id', None, None, ), # 1
7039 
  )
7040 
 
7041 
  def __init__(self, id=None,):
7042 
    self.id = id
7043 
 
7044 
  def read(self, iprot):
7045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7047 
      return
7048 
    iprot.readStructBegin()
7049 
    while True:
7050 
      (fname, ftype, fid) = iprot.readFieldBegin()
7051 
      if ftype == TType.STOP:
7052 
        break
7053 
      if fid == 1:
7054 
        if ftype == TType.I64:
7055 
          self.id = iprot.readI64();
7056 
        else:
7057 
          iprot.skip(ftype)
7058 
      else:
7059 
        iprot.skip(ftype)
7060 
      iprot.readFieldEnd()
7061 
    iprot.readStructEnd()
7062 
 
7063 
  def write(self, oprot):
7064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7066 
      return
7067 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7068 
    if self.id is not None:
94 ashish 7069 
      oprot.writeFieldBegin('id', TType.I64, 1)
7070 
      oprot.writeI64(self.id)
7071 
      oprot.writeFieldEnd()
7072 
    oprot.writeFieldStop()
7073 
    oprot.writeStructEnd()
7074 
 
3431 rajveer 7075 
  def validate(self):
7076 
    return
7077 
 
7078 
 
94 ashish 7079 
  def __repr__(self):
7080 
    L = ['%s=%r' % (key, value)
7081 
      for key, value in self.__dict__.iteritems()]
7082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7083 
 
7084 
  def __eq__(self, other):
7085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7086 
 
7087 
  def __ne__(self, other):
7088 
    return not (self == other)
7089 
 
7090 
class getTransaction_result:
7091 
  """
7092 
  Attributes:
7093 
   - success
7094 
   - ex
7095 
  """
7096 
 
7097 
  thrift_spec = (
7098 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7100 
  )
7101 
 
7102 
  def __init__(self, success=None, ex=None,):
7103 
    self.success = success
7104 
    self.ex = ex
7105 
 
7106 
  def read(self, iprot):
7107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7109 
      return
7110 
    iprot.readStructBegin()
7111 
    while True:
7112 
      (fname, ftype, fid) = iprot.readFieldBegin()
7113 
      if ftype == TType.STOP:
7114 
        break
7115 
      if fid == 0:
7116 
        if ftype == TType.STRUCT:
7117 
          self.success = Transaction()
7118 
          self.success.read(iprot)
7119 
        else:
7120 
          iprot.skip(ftype)
7121 
      elif fid == 1:
7122 
        if ftype == TType.STRUCT:
7123 
          self.ex = TransactionServiceException()
7124 
          self.ex.read(iprot)
7125 
        else:
7126 
          iprot.skip(ftype)
7127 
      else:
7128 
        iprot.skip(ftype)
7129 
      iprot.readFieldEnd()
7130 
    iprot.readStructEnd()
7131 
 
7132 
  def write(self, oprot):
7133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7135 
      return
7136 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7137 
    if self.success is not None:
94 ashish 7138 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7139 
      self.success.write(oprot)
7140 
      oprot.writeFieldEnd()
3431 rajveer 7141 
    if self.ex is not None:
94 ashish 7142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7143 
      self.ex.write(oprot)
7144 
      oprot.writeFieldEnd()
7145 
    oprot.writeFieldStop()
7146 
    oprot.writeStructEnd()
7147 
 
3431 rajveer 7148 
  def validate(self):
7149 
    return
7150 
 
7151 
 
94 ashish 7152 
  def __repr__(self):
7153 
    L = ['%s=%r' % (key, value)
7154 
      for key, value in self.__dict__.iteritems()]
7155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7156 
 
7157 
  def __eq__(self, other):
7158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7159 
 
7160 
  def __ne__(self, other):
7161 
    return not (self == other)
7162 
 
7163 
class getTransactionsForCustomer_args:
7164 
  """
7165 
  Attributes:
7166 
   - customerId
7167 
   - from_date
7168 
   - to_date
7169 
   - status
7170 
  """
7171 
 
7172 
  thrift_spec = (
7173 
    None, # 0
7174 
    (1, TType.I64, 'customerId', None, None, ), # 1
7175 
    (2, TType.I64, 'from_date', None, None, ), # 2
7176 
    (3, TType.I64, 'to_date', None, None, ), # 3
7177 
    (4, TType.I32, 'status', None, None, ), # 4
7178 
  )
7179 
 
7180 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7181 
    self.customerId = customerId
7182 
    self.from_date = from_date
7183 
    self.to_date = to_date
7184 
    self.status = status
7185 
 
7186 
  def read(self, iprot):
7187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7189 
      return
7190 
    iprot.readStructBegin()
7191 
    while True:
7192 
      (fname, ftype, fid) = iprot.readFieldBegin()
7193 
      if ftype == TType.STOP:
7194 
        break
7195 
      if fid == 1:
7196 
        if ftype == TType.I64:
7197 
          self.customerId = iprot.readI64();
7198 
        else:
7199 
          iprot.skip(ftype)
7200 
      elif fid == 2:
7201 
        if ftype == TType.I64:
7202 
          self.from_date = iprot.readI64();
7203 
        else:
7204 
          iprot.skip(ftype)
7205 
      elif fid == 3:
7206 
        if ftype == TType.I64:
7207 
          self.to_date = iprot.readI64();
7208 
        else:
7209 
          iprot.skip(ftype)
7210 
      elif fid == 4:
7211 
        if ftype == TType.I32:
7212 
          self.status = iprot.readI32();
7213 
        else:
7214 
          iprot.skip(ftype)
7215 
      else:
7216 
        iprot.skip(ftype)
7217 
      iprot.readFieldEnd()
7218 
    iprot.readStructEnd()
7219 
 
7220 
  def write(self, oprot):
7221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7223 
      return
7224 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7225 
    if self.customerId is not None:
94 ashish 7226 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7227 
      oprot.writeI64(self.customerId)
7228 
      oprot.writeFieldEnd()
3431 rajveer 7229 
    if self.from_date is not None:
94 ashish 7230 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7231 
      oprot.writeI64(self.from_date)
7232 
      oprot.writeFieldEnd()
3431 rajveer 7233 
    if self.to_date is not None:
94 ashish 7234 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7235 
      oprot.writeI64(self.to_date)
7236 
      oprot.writeFieldEnd()
3431 rajveer 7237 
    if self.status is not None:
94 ashish 7238 
      oprot.writeFieldBegin('status', TType.I32, 4)
7239 
      oprot.writeI32(self.status)
7240 
      oprot.writeFieldEnd()
7241 
    oprot.writeFieldStop()
7242 
    oprot.writeStructEnd()
7243 
 
3431 rajveer 7244 
  def validate(self):
7245 
    return
7246 
 
7247 
 
94 ashish 7248 
  def __repr__(self):
7249 
    L = ['%s=%r' % (key, value)
7250 
      for key, value in self.__dict__.iteritems()]
7251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7252 
 
7253 
  def __eq__(self, other):
7254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7255 
 
7256 
  def __ne__(self, other):
7257 
    return not (self == other)
7258 
 
7259 
class getTransactionsForCustomer_result:
7260 
  """
7261 
  Attributes:
7262 
   - success
7263 
   - ex
7264 
  """
7265 
 
7266 
  thrift_spec = (
7267 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7268 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7269 
  )
7270 
 
7271 
  def __init__(self, success=None, ex=None,):
7272 
    self.success = success
7273 
    self.ex = ex
7274 
 
7275 
  def read(self, iprot):
7276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7278 
      return
7279 
    iprot.readStructBegin()
7280 
    while True:
7281 
      (fname, ftype, fid) = iprot.readFieldBegin()
7282 
      if ftype == TType.STOP:
7283 
        break
7284 
      if fid == 0:
7285 
        if ftype == TType.LIST:
7286 
          self.success = []
5031 varun.gupt 7287 
          (_etype66, _size63) = iprot.readListBegin()
7288 
          for _i67 in xrange(_size63):
7289 
            _elem68 = Transaction()
7290 
            _elem68.read(iprot)
7291 
            self.success.append(_elem68)
94 ashish 7292 
          iprot.readListEnd()
7293 
        else:
7294 
          iprot.skip(ftype)
7295 
      elif fid == 1:
7296 
        if ftype == TType.STRUCT:
7297 
          self.ex = TransactionServiceException()
7298 
          self.ex.read(iprot)
7299 
        else:
7300 
          iprot.skip(ftype)
7301 
      else:
7302 
        iprot.skip(ftype)
7303 
      iprot.readFieldEnd()
7304 
    iprot.readStructEnd()
7305 
 
7306 
  def write(self, oprot):
7307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7309 
      return
7310 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7311 
    if self.success is not None:
94 ashish 7312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7314 
      for iter69 in self.success:
7315 
        iter69.write(oprot)
94 ashish 7316 
      oprot.writeListEnd()
7317 
      oprot.writeFieldEnd()
3431 rajveer 7318 
    if self.ex is not None:
94 ashish 7319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7320 
      self.ex.write(oprot)
7321 
      oprot.writeFieldEnd()
7322 
    oprot.writeFieldStop()
7323 
    oprot.writeStructEnd()
7324 
 
3431 rajveer 7325 
  def validate(self):
7326 
    return
7327 
 
7328 
 
94 ashish 7329 
  def __repr__(self):
7330 
    L = ['%s=%r' % (key, value)
7331 
      for key, value in self.__dict__.iteritems()]
7332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7333 
 
7334 
  def __eq__(self, other):
7335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7336 
 
7337 
  def __ne__(self, other):
7338 
    return not (self == other)
7339 
 
132 ashish 7340 
class getTransactionsForShoppingCartId_args:
7341 
  """
7342 
  Attributes:
7343 
   - shoppingCartId
7344 
  """
7345 
 
7346 
  thrift_spec = (
7347 
    None, # 0
7348 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7349 
  )
7350 
 
7351 
  def __init__(self, shoppingCartId=None,):
7352 
    self.shoppingCartId = shoppingCartId
7353 
 
7354 
  def read(self, iprot):
7355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7357 
      return
7358 
    iprot.readStructBegin()
7359 
    while True:
7360 
      (fname, ftype, fid) = iprot.readFieldBegin()
7361 
      if ftype == TType.STOP:
7362 
        break
7363 
      if fid == 1:
7364 
        if ftype == TType.I64:
7365 
          self.shoppingCartId = iprot.readI64();
7366 
        else:
7367 
          iprot.skip(ftype)
7368 
      else:
7369 
        iprot.skip(ftype)
7370 
      iprot.readFieldEnd()
7371 
    iprot.readStructEnd()
7372 
 
7373 
  def write(self, oprot):
7374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7376 
      return
7377 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7378 
    if self.shoppingCartId is not None:
132 ashish 7379 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7380 
      oprot.writeI64(self.shoppingCartId)
7381 
      oprot.writeFieldEnd()
7382 
    oprot.writeFieldStop()
7383 
    oprot.writeStructEnd()
7384 
 
3431 rajveer 7385 
  def validate(self):
7386 
    return
7387 
 
7388 
 
132 ashish 7389 
  def __repr__(self):
7390 
    L = ['%s=%r' % (key, value)
7391 
      for key, value in self.__dict__.iteritems()]
7392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7393 
 
7394 
  def __eq__(self, other):
7395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7396 
 
7397 
  def __ne__(self, other):
7398 
    return not (self == other)
7399 
 
7400 
class getTransactionsForShoppingCartId_result:
7401 
  """
7402 
  Attributes:
7403 
   - success
7404 
   - ex
7405 
  """
7406 
 
7407 
  thrift_spec = (
7408 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7410 
  )
7411 
 
7412 
  def __init__(self, success=None, ex=None,):
7413 
    self.success = success
7414 
    self.ex = ex
7415 
 
7416 
  def read(self, iprot):
7417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7419 
      return
7420 
    iprot.readStructBegin()
7421 
    while True:
7422 
      (fname, ftype, fid) = iprot.readFieldBegin()
7423 
      if ftype == TType.STOP:
7424 
        break
7425 
      if fid == 0:
7426 
        if ftype == TType.LIST:
7427 
          self.success = []
5031 varun.gupt 7428 
          (_etype73, _size70) = iprot.readListBegin()
7429 
          for _i74 in xrange(_size70):
7430 
            _elem75 = Transaction()
7431 
            _elem75.read(iprot)
7432 
            self.success.append(_elem75)
132 ashish 7433 
          iprot.readListEnd()
7434 
        else:
7435 
          iprot.skip(ftype)
7436 
      elif fid == 1:
7437 
        if ftype == TType.STRUCT:
7438 
          self.ex = TransactionServiceException()
7439 
          self.ex.read(iprot)
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      else:
7443 
        iprot.skip(ftype)
7444 
      iprot.readFieldEnd()
7445 
    iprot.readStructEnd()
7446 
 
7447 
  def write(self, oprot):
7448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7450 
      return
7451 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7452 
    if self.success is not None:
132 ashish 7453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7455 
      for iter76 in self.success:
7456 
        iter76.write(oprot)
132 ashish 7457 
      oprot.writeListEnd()
7458 
      oprot.writeFieldEnd()
3431 rajveer 7459 
    if self.ex is not None:
132 ashish 7460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7461 
      self.ex.write(oprot)
7462 
      oprot.writeFieldEnd()
7463 
    oprot.writeFieldStop()
7464 
    oprot.writeStructEnd()
7465 
 
3431 rajveer 7466 
  def validate(self):
7467 
    return
7468 
 
7469 
 
132 ashish 7470 
  def __repr__(self):
7471 
    L = ['%s=%r' % (key, value)
7472 
      for key, value in self.__dict__.iteritems()]
7473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7474 
 
7475 
  def __eq__(self, other):
7476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7477 
 
7478 
  def __ne__(self, other):
7479 
    return not (self == other)
7480 
 
94 ashish 7481 
class getTransactionStatus_args:
7482 
  """
7483 
  Attributes:
7484 
   - transactionId
7485 
  """
7486 
 
7487 
  thrift_spec = (
7488 
    None, # 0
7489 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7490 
  )
7491 
 
7492 
  def __init__(self, transactionId=None,):
7493 
    self.transactionId = transactionId
7494 
 
7495 
  def read(self, iprot):
7496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7498 
      return
7499 
    iprot.readStructBegin()
7500 
    while True:
7501 
      (fname, ftype, fid) = iprot.readFieldBegin()
7502 
      if ftype == TType.STOP:
7503 
        break
7504 
      if fid == 1:
7505 
        if ftype == TType.I64:
7506 
          self.transactionId = iprot.readI64();
7507 
        else:
7508 
          iprot.skip(ftype)
7509 
      else:
7510 
        iprot.skip(ftype)
7511 
      iprot.readFieldEnd()
7512 
    iprot.readStructEnd()
7513 
 
7514 
  def write(self, oprot):
7515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7517 
      return
7518 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7519 
    if self.transactionId is not None:
94 ashish 7520 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7521 
      oprot.writeI64(self.transactionId)
7522 
      oprot.writeFieldEnd()
7523 
    oprot.writeFieldStop()
7524 
    oprot.writeStructEnd()
7525 
 
3431 rajveer 7526 
  def validate(self):
7527 
    return
7528 
 
7529 
 
94 ashish 7530 
  def __repr__(self):
7531 
    L = ['%s=%r' % (key, value)
7532 
      for key, value in self.__dict__.iteritems()]
7533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7534 
 
7535 
  def __eq__(self, other):
7536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7537 
 
7538 
  def __ne__(self, other):
7539 
    return not (self == other)
7540 
 
7541 
class getTransactionStatus_result:
7542 
  """
7543 
  Attributes:
7544 
   - success
7545 
   - ex
7546 
  """
7547 
 
7548 
  thrift_spec = (
7549 
    (0, TType.I32, 'success', None, None, ), # 0
7550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7551 
  )
7552 
 
7553 
  def __init__(self, success=None, ex=None,):
7554 
    self.success = success
7555 
    self.ex = ex
7556 
 
7557 
  def read(self, iprot):
7558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7560 
      return
7561 
    iprot.readStructBegin()
7562 
    while True:
7563 
      (fname, ftype, fid) = iprot.readFieldBegin()
7564 
      if ftype == TType.STOP:
7565 
        break
7566 
      if fid == 0:
7567 
        if ftype == TType.I32:
7568 
          self.success = iprot.readI32();
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      elif fid == 1:
7572 
        if ftype == TType.STRUCT:
7573 
          self.ex = TransactionServiceException()
7574 
          self.ex.read(iprot)
7575 
        else:
7576 
          iprot.skip(ftype)
7577 
      else:
7578 
        iprot.skip(ftype)
7579 
      iprot.readFieldEnd()
7580 
    iprot.readStructEnd()
7581 
 
7582 
  def write(self, oprot):
7583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7585 
      return
7586 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7587 
    if self.success is not None:
94 ashish 7588 
      oprot.writeFieldBegin('success', TType.I32, 0)
7589 
      oprot.writeI32(self.success)
7590 
      oprot.writeFieldEnd()
3431 rajveer 7591 
    if self.ex is not None:
94 ashish 7592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7593 
      self.ex.write(oprot)
7594 
      oprot.writeFieldEnd()
7595 
    oprot.writeFieldStop()
7596 
    oprot.writeStructEnd()
7597 
 
3431 rajveer 7598 
  def validate(self):
7599 
    return
7600 
 
7601 
 
94 ashish 7602 
  def __repr__(self):
7603 
    L = ['%s=%r' % (key, value)
7604 
      for key, value in self.__dict__.iteritems()]
7605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7606 
 
7607 
  def __eq__(self, other):
7608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7609 
 
7610 
  def __ne__(self, other):
7611 
    return not (self == other)
7612 
 
7613 
class changeTransactionStatus_args:
7614 
  """
7615 
  Attributes:
7616 
   - transactionId
7617 
   - status
7618 
   - description
5387 rajveer 7619 
   - selfPickup
94 ashish 7620 
  """
7621 
 
7622 
  thrift_spec = (
7623 
    None, # 0
7624 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7625 
    (2, TType.I32, 'status', None, None, ), # 2
7626 
    (3, TType.STRING, 'description', None, None, ), # 3
5387 rajveer 7627 
    (4, TType.BOOL, 'selfPickup', None, None, ), # 4
94 ashish 7628 
  )
7629 
 
5387 rajveer 7630 
  def __init__(self, transactionId=None, status=None, description=None, selfPickup=None,):
94 ashish 7631 
    self.transactionId = transactionId
7632 
    self.status = status
7633 
    self.description = description
5387 rajveer 7634 
    self.selfPickup = selfPickup
94 ashish 7635 
 
7636 
  def read(self, iprot):
7637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7639 
      return
7640 
    iprot.readStructBegin()
7641 
    while True:
7642 
      (fname, ftype, fid) = iprot.readFieldBegin()
7643 
      if ftype == TType.STOP:
7644 
        break
7645 
      if fid == 1:
7646 
        if ftype == TType.I64:
7647 
          self.transactionId = iprot.readI64();
7648 
        else:
7649 
          iprot.skip(ftype)
7650 
      elif fid == 2:
7651 
        if ftype == TType.I32:
7652 
          self.status = iprot.readI32();
7653 
        else:
7654 
          iprot.skip(ftype)
7655 
      elif fid == 3:
7656 
        if ftype == TType.STRING:
7657 
          self.description = iprot.readString();
7658 
        else:
7659 
          iprot.skip(ftype)
5387 rajveer 7660 
      elif fid == 4:
7661 
        if ftype == TType.BOOL:
7662 
          self.selfPickup = iprot.readBool();
7663 
        else:
7664 
          iprot.skip(ftype)
94 ashish 7665 
      else:
7666 
        iprot.skip(ftype)
7667 
      iprot.readFieldEnd()
7668 
    iprot.readStructEnd()
7669 
 
7670 
  def write(self, oprot):
7671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7673 
      return
7674 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7675 
    if self.transactionId is not None:
94 ashish 7676 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7677 
      oprot.writeI64(self.transactionId)
7678 
      oprot.writeFieldEnd()
3431 rajveer 7679 
    if self.status is not None:
94 ashish 7680 
      oprot.writeFieldBegin('status', TType.I32, 2)
7681 
      oprot.writeI32(self.status)
7682 
      oprot.writeFieldEnd()
3431 rajveer 7683 
    if self.description is not None:
94 ashish 7684 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7685 
      oprot.writeString(self.description)
7686 
      oprot.writeFieldEnd()
5387 rajveer 7687 
    if self.selfPickup is not None:
7688 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 4)
7689 
      oprot.writeBool(self.selfPickup)
7690 
      oprot.writeFieldEnd()
94 ashish 7691 
    oprot.writeFieldStop()
7692 
    oprot.writeStructEnd()
7693 
 
3431 rajveer 7694 
  def validate(self):
7695 
    return
7696 
 
7697 
 
94 ashish 7698 
  def __repr__(self):
7699 
    L = ['%s=%r' % (key, value)
7700 
      for key, value in self.__dict__.iteritems()]
7701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7702 
 
7703 
  def __eq__(self, other):
7704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7705 
 
7706 
  def __ne__(self, other):
7707 
    return not (self == other)
7708 
 
7709 
class changeTransactionStatus_result:
7710 
  """
7711 
  Attributes:
7712 
   - success
7713 
   - ex
7714 
  """
7715 
 
7716 
  thrift_spec = (
7717 
    (0, TType.BOOL, 'success', None, None, ), # 0
7718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7719 
  )
7720 
 
7721 
  def __init__(self, success=None, ex=None,):
7722 
    self.success = success
7723 
    self.ex = ex
7724 
 
7725 
  def read(self, iprot):
7726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7728 
      return
7729 
    iprot.readStructBegin()
7730 
    while True:
7731 
      (fname, ftype, fid) = iprot.readFieldBegin()
7732 
      if ftype == TType.STOP:
7733 
        break
7734 
      if fid == 0:
7735 
        if ftype == TType.BOOL:
7736 
          self.success = iprot.readBool();
7737 
        else:
7738 
          iprot.skip(ftype)
7739 
      elif fid == 1:
7740 
        if ftype == TType.STRUCT:
7741 
          self.ex = TransactionServiceException()
7742 
          self.ex.read(iprot)
7743 
        else:
7744 
          iprot.skip(ftype)
7745 
      else:
7746 
        iprot.skip(ftype)
7747 
      iprot.readFieldEnd()
7748 
    iprot.readStructEnd()
7749 
 
7750 
  def write(self, oprot):
7751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7753 
      return
7754 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7755 
    if self.success is not None:
94 ashish 7756 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7757 
      oprot.writeBool(self.success)
7758 
      oprot.writeFieldEnd()
3431 rajveer 7759 
    if self.ex is not None:
94 ashish 7760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7761 
      self.ex.write(oprot)
7762 
      oprot.writeFieldEnd()
7763 
    oprot.writeFieldStop()
7764 
    oprot.writeStructEnd()
7765 
 
3431 rajveer 7766 
  def validate(self):
7767 
    return
7768 
 
7769 
 
94 ashish 7770 
  def __repr__(self):
7771 
    L = ['%s=%r' % (key, value)
7772 
      for key, value in self.__dict__.iteritems()]
7773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7774 
 
7775 
  def __eq__(self, other):
7776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7777 
 
7778 
  def __ne__(self, other):
7779 
    return not (self == other)
7780 
 
1398 varun.gupt 7781 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7782 
  """
7783 
  Attributes:
7784 
   - transactionId
7785 
  """
7786 
 
7787 
  thrift_spec = (
7788 
    None, # 0
7789 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7790 
  )
7791 
 
7792 
  def __init__(self, transactionId=None,):
7793 
    self.transactionId = transactionId
7794 
 
7795 
  def read(self, iprot):
7796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7798 
      return
7799 
    iprot.readStructBegin()
7800 
    while True:
7801 
      (fname, ftype, fid) = iprot.readFieldBegin()
7802 
      if ftype == TType.STOP:
7803 
        break
7804 
      if fid == 1:
7805 
        if ftype == TType.I64:
7806 
          self.transactionId = iprot.readI64();
7807 
        else:
7808 
          iprot.skip(ftype)
7809 
      else:
7810 
        iprot.skip(ftype)
7811 
      iprot.readFieldEnd()
7812 
    iprot.readStructEnd()
7813 
 
7814 
  def write(self, oprot):
7815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7817 
      return
1398 varun.gupt 7818 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7819 
    if self.transactionId is not None:
1382 varun.gupt 7820 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7821 
      oprot.writeI64(self.transactionId)
7822 
      oprot.writeFieldEnd()
7823 
    oprot.writeFieldStop()
7824 
    oprot.writeStructEnd()
7825 
 
3431 rajveer 7826 
  def validate(self):
7827 
    return
7828 
 
7829 
 
1382 varun.gupt 7830 
  def __repr__(self):
7831 
    L = ['%s=%r' % (key, value)
7832 
      for key, value in self.__dict__.iteritems()]
7833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7834 
 
7835 
  def __eq__(self, other):
7836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7837 
 
7838 
  def __ne__(self, other):
7839 
    return not (self == other)
7840 
 
1398 varun.gupt 7841 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7842 
  """
7843 
  Attributes:
7844 
   - success
7845 
   - ex
7846 
  """
7847 
 
7848 
  thrift_spec = (
7849 
    (0, TType.BOOL, 'success', None, None, ), # 0
7850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7851 
  )
7852 
 
7853 
  def __init__(self, success=None, ex=None,):
7854 
    self.success = success
7855 
    self.ex = ex
7856 
 
7857 
  def read(self, iprot):
7858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7860 
      return
7861 
    iprot.readStructBegin()
7862 
    while True:
7863 
      (fname, ftype, fid) = iprot.readFieldBegin()
7864 
      if ftype == TType.STOP:
7865 
        break
7866 
      if fid == 0:
7867 
        if ftype == TType.BOOL:
7868 
          self.success = iprot.readBool();
7869 
        else:
7870 
          iprot.skip(ftype)
7871 
      elif fid == 1:
7872 
        if ftype == TType.STRUCT:
7873 
          self.ex = TransactionServiceException()
7874 
          self.ex.read(iprot)
7875 
        else:
7876 
          iprot.skip(ftype)
7877 
      else:
7878 
        iprot.skip(ftype)
7879 
      iprot.readFieldEnd()
7880 
    iprot.readStructEnd()
7881 
 
7882 
  def write(self, oprot):
7883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7885 
      return
1398 varun.gupt 7886 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7887 
    if self.success is not None:
1382 varun.gupt 7888 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7889 
      oprot.writeBool(self.success)
7890 
      oprot.writeFieldEnd()
3431 rajveer 7891 
    if self.ex is not None:
1382 varun.gupt 7892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7893 
      self.ex.write(oprot)
7894 
      oprot.writeFieldEnd()
7895 
    oprot.writeFieldStop()
7896 
    oprot.writeStructEnd()
7897 
 
3431 rajveer 7898 
  def validate(self):
7899 
    return
7900 
 
7901 
 
1382 varun.gupt 7902 
  def __repr__(self):
7903 
    L = ['%s=%r' % (key, value)
7904 
      for key, value in self.__dict__.iteritems()]
7905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7906 
 
7907 
  def __eq__(self, other):
7908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7909 
 
7910 
  def __ne__(self, other):
7911 
    return not (self == other)
7912 
 
483 rajveer 7913 
class getAllOrders_args:
94 ashish 7914 
  """
7915 
  Attributes:
4801 anupam.sin 7916 
   - statuses
483 rajveer 7917 
   - from_date
7918 
   - to_date
7919 
   - warehouse_id
94 ashish 7920 
  """
7921 
 
7922 
  thrift_spec = (
7923 
    None, # 0
4801 anupam.sin 7924 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7925 
    (2, TType.I64, 'from_date', None, None, ), # 2
7926 
    (3, TType.I64, 'to_date', None, None, ), # 3
7927 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7928 
  )
7929 
 
4801 anupam.sin 7930 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7931 
    self.statuses = statuses
483 rajveer 7932 
    self.from_date = from_date
7933 
    self.to_date = to_date
7934 
    self.warehouse_id = warehouse_id
94 ashish 7935 
 
7936 
  def read(self, iprot):
7937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7939 
      return
7940 
    iprot.readStructBegin()
7941 
    while True:
7942 
      (fname, ftype, fid) = iprot.readFieldBegin()
7943 
      if ftype == TType.STOP:
7944 
        break
7945 
      if fid == 1:
4801 anupam.sin 7946 
        if ftype == TType.LIST:
7947 
          self.statuses = []
5031 varun.gupt 7948 
          (_etype80, _size77) = iprot.readListBegin()
7949 
          for _i81 in xrange(_size77):
7950 
            _elem82 = iprot.readI32();
7951 
            self.statuses.append(_elem82)
4801 anupam.sin 7952 
          iprot.readListEnd()
94 ashish 7953 
        else:
7954 
          iprot.skip(ftype)
483 rajveer 7955 
      elif fid == 2:
7956 
        if ftype == TType.I64:
7957 
          self.from_date = iprot.readI64();
94 ashish 7958 
        else:
7959 
          iprot.skip(ftype)
483 rajveer 7960 
      elif fid == 3:
7961 
        if ftype == TType.I64:
7962 
          self.to_date = iprot.readI64();
94 ashish 7963 
        else:
7964 
          iprot.skip(ftype)
483 rajveer 7965 
      elif fid == 4:
94 ashish 7966 
        if ftype == TType.I64:
483 rajveer 7967 
          self.warehouse_id = iprot.readI64();
94 ashish 7968 
        else:
7969 
          iprot.skip(ftype)
7970 
      else:
7971 
        iprot.skip(ftype)
7972 
      iprot.readFieldEnd()
7973 
    iprot.readStructEnd()
7974 
 
7975 
  def write(self, oprot):
7976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7978 
      return
483 rajveer 7979 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7980 
    if self.statuses is not None:
7981 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7982 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7983 
      for iter83 in self.statuses:
7984 
        oprot.writeI32(iter83)
4801 anupam.sin 7985 
      oprot.writeListEnd()
94 ashish 7986 
      oprot.writeFieldEnd()
3431 rajveer 7987 
    if self.from_date is not None:
483 rajveer 7988 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7989 
      oprot.writeI64(self.from_date)
94 ashish 7990 
      oprot.writeFieldEnd()
3431 rajveer 7991 
    if self.to_date is not None:
483 rajveer 7992 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7993 
      oprot.writeI64(self.to_date)
94 ashish 7994 
      oprot.writeFieldEnd()
3431 rajveer 7995 
    if self.warehouse_id is not None:
483 rajveer 7996 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7997 
      oprot.writeI64(self.warehouse_id)
94 ashish 7998 
      oprot.writeFieldEnd()
7999 
    oprot.writeFieldStop()
8000 
    oprot.writeStructEnd()
8001 
 
3431 rajveer 8002 
  def validate(self):
8003 
    return
8004 
 
8005 
 
94 ashish 8006 
  def __repr__(self):
8007 
    L = ['%s=%r' % (key, value)
8008 
      for key, value in self.__dict__.iteritems()]
8009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8010 
 
8011 
  def __eq__(self, other):
8012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8013 
 
8014 
  def __ne__(self, other):
8015 
    return not (self == other)
8016 
 
483 rajveer 8017 
class getAllOrders_result:
94 ashish 8018 
  """
8019 
  Attributes:
8020 
   - success
8021 
   - ex
8022 
  """
8023 
 
8024 
  thrift_spec = (
483 rajveer 8025 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8027 
  )
8028 
 
8029 
  def __init__(self, success=None, ex=None,):
8030 
    self.success = success
8031 
    self.ex = ex
8032 
 
8033 
  def read(self, iprot):
8034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8036 
      return
8037 
    iprot.readStructBegin()
8038 
    while True:
8039 
      (fname, ftype, fid) = iprot.readFieldBegin()
8040 
      if ftype == TType.STOP:
8041 
        break
8042 
      if fid == 0:
483 rajveer 8043 
        if ftype == TType.LIST:
8044 
          self.success = []
5031 varun.gupt 8045 
          (_etype87, _size84) = iprot.readListBegin()
8046 
          for _i88 in xrange(_size84):
8047 
            _elem89 = Order()
8048 
            _elem89.read(iprot)
8049 
            self.success.append(_elem89)
483 rajveer 8050 
          iprot.readListEnd()
94 ashish 8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      elif fid == 1:
8054 
        if ftype == TType.STRUCT:
8055 
          self.ex = TransactionServiceException()
8056 
          self.ex.read(iprot)
8057 
        else:
8058 
          iprot.skip(ftype)
8059 
      else:
8060 
        iprot.skip(ftype)
8061 
      iprot.readFieldEnd()
8062 
    iprot.readStructEnd()
8063 
 
8064 
  def write(self, oprot):
8065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8067 
      return
483 rajveer 8068 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8069 
    if self.success is not None:
483 rajveer 8070 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8071 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8072 
      for iter90 in self.success:
8073 
        iter90.write(oprot)
483 rajveer 8074 
      oprot.writeListEnd()
94 ashish 8075 
      oprot.writeFieldEnd()
3431 rajveer 8076 
    if self.ex is not None:
94 ashish 8077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8078 
      self.ex.write(oprot)
8079 
      oprot.writeFieldEnd()
8080 
    oprot.writeFieldStop()
8081 
    oprot.writeStructEnd()
8082 
 
3431 rajveer 8083 
  def validate(self):
8084 
    return
8085 
 
8086 
 
94 ashish 8087 
  def __repr__(self):
8088 
    L = ['%s=%r' % (key, value)
8089 
      for key, value in self.__dict__.iteritems()]
8090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8091 
 
8092 
  def __eq__(self, other):
8093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8094 
 
8095 
  def __ne__(self, other):
8096 
    return not (self == other)
8097 
 
4133 chandransh 8098 
class getOrdersInBatch_args:
8099 
  """
8100 
  Attributes:
8101 
   - statuses
8102 
   - offset
8103 
   - limit
8104 
   - warehouse_id
8105 
  """
8106 
 
8107 
  thrift_spec = (
8108 
    None, # 0
8109 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8110 
    (2, TType.I64, 'offset', None, None, ), # 2
8111 
    (3, TType.I64, 'limit', None, None, ), # 3
8112 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8113 
  )
8114 
 
8115 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8116 
    self.statuses = statuses
8117 
    self.offset = offset
8118 
    self.limit = limit
8119 
    self.warehouse_id = warehouse_id
8120 
 
8121 
  def read(self, iprot):
8122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8124 
      return
8125 
    iprot.readStructBegin()
8126 
    while True:
8127 
      (fname, ftype, fid) = iprot.readFieldBegin()
8128 
      if ftype == TType.STOP:
8129 
        break
8130 
      if fid == 1:
8131 
        if ftype == TType.LIST:
8132 
          self.statuses = []
5031 varun.gupt 8133 
          (_etype94, _size91) = iprot.readListBegin()
8134 
          for _i95 in xrange(_size91):
8135 
            _elem96 = iprot.readI32();
8136 
            self.statuses.append(_elem96)
4133 chandransh 8137 
          iprot.readListEnd()
8138 
        else:
8139 
          iprot.skip(ftype)
8140 
      elif fid == 2:
8141 
        if ftype == TType.I64:
8142 
          self.offset = iprot.readI64();
8143 
        else:
8144 
          iprot.skip(ftype)
8145 
      elif fid == 3:
8146 
        if ftype == TType.I64:
8147 
          self.limit = iprot.readI64();
8148 
        else:
8149 
          iprot.skip(ftype)
8150 
      elif fid == 4:
8151 
        if ftype == TType.I64:
8152 
          self.warehouse_id = iprot.readI64();
8153 
        else:
8154 
          iprot.skip(ftype)
8155 
      else:
8156 
        iprot.skip(ftype)
8157 
      iprot.readFieldEnd()
8158 
    iprot.readStructEnd()
8159 
 
8160 
  def write(self, oprot):
8161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8163 
      return
8164 
    oprot.writeStructBegin('getOrdersInBatch_args')
8165 
    if self.statuses is not None:
8166 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8167 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8168 
      for iter97 in self.statuses:
8169 
        oprot.writeI32(iter97)
4133 chandransh 8170 
      oprot.writeListEnd()
8171 
      oprot.writeFieldEnd()
8172 
    if self.offset is not None:
8173 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8174 
      oprot.writeI64(self.offset)
8175 
      oprot.writeFieldEnd()
8176 
    if self.limit is not None:
8177 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8178 
      oprot.writeI64(self.limit)
8179 
      oprot.writeFieldEnd()
8180 
    if self.warehouse_id is not None:
8181 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8182 
      oprot.writeI64(self.warehouse_id)
8183 
      oprot.writeFieldEnd()
8184 
    oprot.writeFieldStop()
8185 
    oprot.writeStructEnd()
8186 
 
8187 
  def validate(self):
8188 
    return
8189 
 
8190 
 
8191 
  def __repr__(self):
8192 
    L = ['%s=%r' % (key, value)
8193 
      for key, value in self.__dict__.iteritems()]
8194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8195 
 
8196 
  def __eq__(self, other):
8197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8198 
 
8199 
  def __ne__(self, other):
8200 
    return not (self == other)
8201 
 
8202 
class getOrdersInBatch_result:
8203 
  """
8204 
  Attributes:
8205 
   - success
8206 
   - ex
8207 
  """
8208 
 
8209 
  thrift_spec = (
8210 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8211 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8212 
  )
8213 
 
8214 
  def __init__(self, success=None, ex=None,):
8215 
    self.success = success
8216 
    self.ex = ex
8217 
 
8218 
  def read(self, iprot):
8219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8221 
      return
8222 
    iprot.readStructBegin()
8223 
    while True:
8224 
      (fname, ftype, fid) = iprot.readFieldBegin()
8225 
      if ftype == TType.STOP:
8226 
        break
8227 
      if fid == 0:
8228 
        if ftype == TType.LIST:
8229 
          self.success = []
5031 varun.gupt 8230 
          (_etype101, _size98) = iprot.readListBegin()
8231 
          for _i102 in xrange(_size98):
8232 
            _elem103 = Order()
8233 
            _elem103.read(iprot)
8234 
            self.success.append(_elem103)
4133 chandransh 8235 
          iprot.readListEnd()
8236 
        else:
8237 
          iprot.skip(ftype)
8238 
      elif fid == 1:
8239 
        if ftype == TType.STRUCT:
8240 
          self.ex = TransactionServiceException()
8241 
          self.ex.read(iprot)
8242 
        else:
8243 
          iprot.skip(ftype)
8244 
      else:
8245 
        iprot.skip(ftype)
8246 
      iprot.readFieldEnd()
8247 
    iprot.readStructEnd()
8248 
 
8249 
  def write(self, oprot):
8250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8252 
      return
8253 
    oprot.writeStructBegin('getOrdersInBatch_result')
8254 
    if self.success is not None:
8255 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8256 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8257 
      for iter104 in self.success:
8258 
        iter104.write(oprot)
4133 chandransh 8259 
      oprot.writeListEnd()
8260 
      oprot.writeFieldEnd()
8261 
    if self.ex is not None:
8262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8263 
      self.ex.write(oprot)
8264 
      oprot.writeFieldEnd()
8265 
    oprot.writeFieldStop()
8266 
    oprot.writeStructEnd()
8267 
 
8268 
  def validate(self):
8269 
    return
8270 
 
8271 
 
8272 
  def __repr__(self):
8273 
    L = ['%s=%r' % (key, value)
8274 
      for key, value in self.__dict__.iteritems()]
8275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8276 
 
8277 
  def __eq__(self, other):
8278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8279 
 
8280 
  def __ne__(self, other):
8281 
    return not (self == other)
8282 
 
8283 
class getOrderCount_args:
8284 
  """
8285 
  Attributes:
8286 
   - statuses
8287 
   - warehouseId
8288 
  """
8289 
 
8290 
  thrift_spec = (
8291 
    None, # 0
8292 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8293 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8294 
  )
8295 
 
8296 
  def __init__(self, statuses=None, warehouseId=None,):
8297 
    self.statuses = statuses
8298 
    self.warehouseId = warehouseId
8299 
 
8300 
  def read(self, iprot):
8301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8303 
      return
8304 
    iprot.readStructBegin()
8305 
    while True:
8306 
      (fname, ftype, fid) = iprot.readFieldBegin()
8307 
      if ftype == TType.STOP:
8308 
        break
8309 
      if fid == 1:
8310 
        if ftype == TType.LIST:
8311 
          self.statuses = []
5031 varun.gupt 8312 
          (_etype108, _size105) = iprot.readListBegin()
8313 
          for _i109 in xrange(_size105):
8314 
            _elem110 = iprot.readI32();
8315 
            self.statuses.append(_elem110)
4133 chandransh 8316 
          iprot.readListEnd()
8317 
        else:
8318 
          iprot.skip(ftype)
8319 
      elif fid == 2:
8320 
        if ftype == TType.I64:
8321 
          self.warehouseId = iprot.readI64();
8322 
        else:
8323 
          iprot.skip(ftype)
8324 
      else:
8325 
        iprot.skip(ftype)
8326 
      iprot.readFieldEnd()
8327 
    iprot.readStructEnd()
8328 
 
8329 
  def write(self, oprot):
8330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8332 
      return
8333 
    oprot.writeStructBegin('getOrderCount_args')
8334 
    if self.statuses is not None:
8335 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8336 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8337 
      for iter111 in self.statuses:
8338 
        oprot.writeI32(iter111)
4133 chandransh 8339 
      oprot.writeListEnd()
8340 
      oprot.writeFieldEnd()
8341 
    if self.warehouseId is not None:
8342 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8343 
      oprot.writeI64(self.warehouseId)
8344 
      oprot.writeFieldEnd()
8345 
    oprot.writeFieldStop()
8346 
    oprot.writeStructEnd()
8347 
 
8348 
  def validate(self):
8349 
    return
8350 
 
8351 
 
8352 
  def __repr__(self):
8353 
    L = ['%s=%r' % (key, value)
8354 
      for key, value in self.__dict__.iteritems()]
8355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8356 
 
8357 
  def __eq__(self, other):
8358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8359 
 
8360 
  def __ne__(self, other):
8361 
    return not (self == other)
8362 
 
8363 
class getOrderCount_result:
8364 
  """
8365 
  Attributes:
8366 
   - success
8367 
   - ex
8368 
  """
8369 
 
8370 
  thrift_spec = (
8371 
    (0, TType.I32, 'success', None, None, ), # 0
8372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8373 
  )
8374 
 
8375 
  def __init__(self, success=None, ex=None,):
8376 
    self.success = success
8377 
    self.ex = ex
8378 
 
8379 
  def read(self, iprot):
8380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8382 
      return
8383 
    iprot.readStructBegin()
8384 
    while True:
8385 
      (fname, ftype, fid) = iprot.readFieldBegin()
8386 
      if ftype == TType.STOP:
8387 
        break
8388 
      if fid == 0:
8389 
        if ftype == TType.I32:
8390 
          self.success = iprot.readI32();
8391 
        else:
8392 
          iprot.skip(ftype)
8393 
      elif fid == 1:
8394 
        if ftype == TType.STRUCT:
8395 
          self.ex = TransactionServiceException()
8396 
          self.ex.read(iprot)
8397 
        else:
8398 
          iprot.skip(ftype)
8399 
      else:
8400 
        iprot.skip(ftype)
8401 
      iprot.readFieldEnd()
8402 
    iprot.readStructEnd()
8403 
 
8404 
  def write(self, oprot):
8405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8407 
      return
8408 
    oprot.writeStructBegin('getOrderCount_result')
8409 
    if self.success is not None:
8410 
      oprot.writeFieldBegin('success', TType.I32, 0)
8411 
      oprot.writeI32(self.success)
8412 
      oprot.writeFieldEnd()
8413 
    if self.ex is not None:
8414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8415 
      self.ex.write(oprot)
8416 
      oprot.writeFieldEnd()
8417 
    oprot.writeFieldStop()
8418 
    oprot.writeStructEnd()
8419 
 
8420 
  def validate(self):
8421 
    return
8422 
 
8423 
 
8424 
  def __repr__(self):
8425 
    L = ['%s=%r' % (key, value)
8426 
      for key, value in self.__dict__.iteritems()]
8427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8428 
 
8429 
  def __eq__(self, other):
8430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8431 
 
8432 
  def __ne__(self, other):
8433 
    return not (self == other)
8434 
 
999 varun.gupt 8435 
class getOrdersByBillingDate_args:
8436 
  """
8437 
  Attributes:
8438 
   - status
8439 
   - start_billing_date
8440 
   - end_billing_date
8441 
   - warehouse_id
8442 
  """
8443 
 
8444 
  thrift_spec = (
8445 
    None, # 0
8446 
    (1, TType.I32, 'status', None, None, ), # 1
8447 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8448 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8449 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8450 
  )
8451 
 
8452 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8453 
    self.status = status
8454 
    self.start_billing_date = start_billing_date
8455 
    self.end_billing_date = end_billing_date
8456 
    self.warehouse_id = warehouse_id
8457 
 
8458 
  def read(self, iprot):
8459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8461 
      return
8462 
    iprot.readStructBegin()
8463 
    while True:
8464 
      (fname, ftype, fid) = iprot.readFieldBegin()
8465 
      if ftype == TType.STOP:
8466 
        break
8467 
      if fid == 1:
8468 
        if ftype == TType.I32:
8469 
          self.status = iprot.readI32();
8470 
        else:
8471 
          iprot.skip(ftype)
8472 
      elif fid == 2:
8473 
        if ftype == TType.I64:
8474 
          self.start_billing_date = iprot.readI64();
8475 
        else:
8476 
          iprot.skip(ftype)
8477 
      elif fid == 3:
8478 
        if ftype == TType.I64:
8479 
          self.end_billing_date = iprot.readI64();
8480 
        else:
8481 
          iprot.skip(ftype)
8482 
      elif fid == 4:
8483 
        if ftype == TType.I64:
8484 
          self.warehouse_id = iprot.readI64();
8485 
        else:
8486 
          iprot.skip(ftype)
8487 
      else:
8488 
        iprot.skip(ftype)
8489 
      iprot.readFieldEnd()
8490 
    iprot.readStructEnd()
8491 
 
8492 
  def write(self, oprot):
8493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8495 
      return
8496 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8497 
    if self.status is not None:
999 varun.gupt 8498 
      oprot.writeFieldBegin('status', TType.I32, 1)
8499 
      oprot.writeI32(self.status)
8500 
      oprot.writeFieldEnd()
3431 rajveer 8501 
    if self.start_billing_date is not None:
999 varun.gupt 8502 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8503 
      oprot.writeI64(self.start_billing_date)
8504 
      oprot.writeFieldEnd()
3431 rajveer 8505 
    if self.end_billing_date is not None:
999 varun.gupt 8506 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8507 
      oprot.writeI64(self.end_billing_date)
8508 
      oprot.writeFieldEnd()
3431 rajveer 8509 
    if self.warehouse_id is not None:
999 varun.gupt 8510 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8511 
      oprot.writeI64(self.warehouse_id)
8512 
      oprot.writeFieldEnd()
8513 
    oprot.writeFieldStop()
8514 
    oprot.writeStructEnd()
8515 
 
3431 rajveer 8516 
  def validate(self):
8517 
    return
8518 
 
8519 
 
999 varun.gupt 8520 
  def __repr__(self):
8521 
    L = ['%s=%r' % (key, value)
8522 
      for key, value in self.__dict__.iteritems()]
8523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8524 
 
8525 
  def __eq__(self, other):
8526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8527 
 
8528 
  def __ne__(self, other):
8529 
    return not (self == other)
8530 
 
8531 
class getOrdersByBillingDate_result:
8532 
  """
8533 
  Attributes:
8534 
   - success
8535 
   - ex
8536 
  """
8537 
 
8538 
  thrift_spec = (
8539 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8541 
  )
8542 
 
8543 
  def __init__(self, success=None, ex=None,):
8544 
    self.success = success
8545 
    self.ex = ex
8546 
 
8547 
  def read(self, iprot):
8548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8550 
      return
8551 
    iprot.readStructBegin()
8552 
    while True:
8553 
      (fname, ftype, fid) = iprot.readFieldBegin()
8554 
      if ftype == TType.STOP:
8555 
        break
8556 
      if fid == 0:
8557 
        if ftype == TType.LIST:
8558 
          self.success = []
5031 varun.gupt 8559 
          (_etype115, _size112) = iprot.readListBegin()
8560 
          for _i116 in xrange(_size112):
8561 
            _elem117 = Order()
8562 
            _elem117.read(iprot)
8563 
            self.success.append(_elem117)
999 varun.gupt 8564 
          iprot.readListEnd()
8565 
        else:
8566 
          iprot.skip(ftype)
8567 
      elif fid == 1:
8568 
        if ftype == TType.STRUCT:
8569 
          self.ex = TransactionServiceException()
8570 
          self.ex.read(iprot)
8571 
        else:
8572 
          iprot.skip(ftype)
8573 
      else:
8574 
        iprot.skip(ftype)
8575 
      iprot.readFieldEnd()
8576 
    iprot.readStructEnd()
8577 
 
8578 
  def write(self, oprot):
8579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8581 
      return
8582 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8583 
    if self.success is not None:
999 varun.gupt 8584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8586 
      for iter118 in self.success:
8587 
        iter118.write(oprot)
999 varun.gupt 8588 
      oprot.writeListEnd()
8589 
      oprot.writeFieldEnd()
3431 rajveer 8590 
    if self.ex is not None:
999 varun.gupt 8591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8592 
      self.ex.write(oprot)
8593 
      oprot.writeFieldEnd()
8594 
    oprot.writeFieldStop()
8595 
    oprot.writeStructEnd()
8596 
 
3431 rajveer 8597 
  def validate(self):
8598 
    return
8599 
 
8600 
 
999 varun.gupt 8601 
  def __repr__(self):
8602 
    L = ['%s=%r' % (key, value)
8603 
      for key, value in self.__dict__.iteritems()]
8604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8605 
 
8606 
  def __eq__(self, other):
8607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8608 
 
8609 
  def __ne__(self, other):
8610 
    return not (self == other)
8611 
 
3427 chandransh 8612 
class getOrdersByShippingDate_args:
8613 
  """
8614 
  Attributes:
8615 
   - fromShippingDate
8616 
   - toShippingDate
8617 
   - providerId
8618 
   - warehouseId
3451 chandransh 8619 
   - cod
3427 chandransh 8620 
  """
8621 
 
8622 
  thrift_spec = (
8623 
    None, # 0
8624 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8625 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8626 
    (3, TType.I64, 'providerId', None, None, ), # 3
8627 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8628 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8629 
  )
8630 
 
3451 chandransh 8631 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8632 
    self.fromShippingDate = fromShippingDate
8633 
    self.toShippingDate = toShippingDate
8634 
    self.providerId = providerId
8635 
    self.warehouseId = warehouseId
3451 chandransh 8636 
    self.cod = cod
3427 chandransh 8637 
 
8638 
  def read(self, iprot):
8639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8641 
      return
8642 
    iprot.readStructBegin()
8643 
    while True:
8644 
      (fname, ftype, fid) = iprot.readFieldBegin()
8645 
      if ftype == TType.STOP:
8646 
        break
8647 
      if fid == 1:
8648 
        if ftype == TType.I64:
8649 
          self.fromShippingDate = iprot.readI64();
8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      elif fid == 2:
8653 
        if ftype == TType.I64:
8654 
          self.toShippingDate = iprot.readI64();
8655 
        else:
8656 
          iprot.skip(ftype)
8657 
      elif fid == 3:
8658 
        if ftype == TType.I64:
8659 
          self.providerId = iprot.readI64();
8660 
        else:
8661 
          iprot.skip(ftype)
8662 
      elif fid == 4:
8663 
        if ftype == TType.I64:
8664 
          self.warehouseId = iprot.readI64();
8665 
        else:
8666 
          iprot.skip(ftype)
3451 chandransh 8667 
      elif fid == 5:
8668 
        if ftype == TType.BOOL:
8669 
          self.cod = iprot.readBool();
8670 
        else:
8671 
          iprot.skip(ftype)
3427 chandransh 8672 
      else:
8673 
        iprot.skip(ftype)
8674 
      iprot.readFieldEnd()
8675 
    iprot.readStructEnd()
8676 
 
8677 
  def write(self, oprot):
8678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8680 
      return
8681 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8682 
    if self.fromShippingDate is not None:
3427 chandransh 8683 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8684 
      oprot.writeI64(self.fromShippingDate)
8685 
      oprot.writeFieldEnd()
3431 rajveer 8686 
    if self.toShippingDate is not None:
3427 chandransh 8687 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8688 
      oprot.writeI64(self.toShippingDate)
8689 
      oprot.writeFieldEnd()
3431 rajveer 8690 
    if self.providerId is not None:
3427 chandransh 8691 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8692 
      oprot.writeI64(self.providerId)
8693 
      oprot.writeFieldEnd()
3431 rajveer 8694 
    if self.warehouseId is not None:
3427 chandransh 8695 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8696 
      oprot.writeI64(self.warehouseId)
8697 
      oprot.writeFieldEnd()
3451 chandransh 8698 
    if self.cod is not None:
8699 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8700 
      oprot.writeBool(self.cod)
8701 
      oprot.writeFieldEnd()
3427 chandransh 8702 
    oprot.writeFieldStop()
8703 
    oprot.writeStructEnd()
8704 
 
3431 rajveer 8705 
  def validate(self):
8706 
    return
8707 
 
8708 
 
3427 chandransh 8709 
  def __repr__(self):
8710 
    L = ['%s=%r' % (key, value)
8711 
      for key, value in self.__dict__.iteritems()]
8712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8713 
 
8714 
  def __eq__(self, other):
8715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8716 
 
8717 
  def __ne__(self, other):
8718 
    return not (self == other)
8719 
 
8720 
class getOrdersByShippingDate_result:
8721 
  """
8722 
  Attributes:
8723 
   - success
8724 
   - ex
8725 
  """
8726 
 
8727 
  thrift_spec = (
8728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8730 
  )
8731 
 
8732 
  def __init__(self, success=None, ex=None,):
8733 
    self.success = success
8734 
    self.ex = ex
8735 
 
8736 
  def read(self, iprot):
8737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8739 
      return
8740 
    iprot.readStructBegin()
8741 
    while True:
8742 
      (fname, ftype, fid) = iprot.readFieldBegin()
8743 
      if ftype == TType.STOP:
8744 
        break
8745 
      if fid == 0:
8746 
        if ftype == TType.LIST:
8747 
          self.success = []
5031 varun.gupt 8748 
          (_etype122, _size119) = iprot.readListBegin()
8749 
          for _i123 in xrange(_size119):
8750 
            _elem124 = Order()
8751 
            _elem124.read(iprot)
8752 
            self.success.append(_elem124)
3427 chandransh 8753 
          iprot.readListEnd()
8754 
        else:
8755 
          iprot.skip(ftype)
8756 
      elif fid == 1:
8757 
        if ftype == TType.STRUCT:
8758 
          self.ex = TransactionServiceException()
8759 
          self.ex.read(iprot)
8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      else:
8763 
        iprot.skip(ftype)
8764 
      iprot.readFieldEnd()
8765 
    iprot.readStructEnd()
8766 
 
8767 
  def write(self, oprot):
8768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8770 
      return
8771 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8772 
    if self.success is not None:
3427 chandransh 8773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8775 
      for iter125 in self.success:
8776 
        iter125.write(oprot)
3427 chandransh 8777 
      oprot.writeListEnd()
8778 
      oprot.writeFieldEnd()
3431 rajveer 8779 
    if self.ex is not None:
3427 chandransh 8780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8781 
      self.ex.write(oprot)
8782 
      oprot.writeFieldEnd()
8783 
    oprot.writeFieldStop()
8784 
    oprot.writeStructEnd()
8785 
 
3431 rajveer 8786 
  def validate(self):
8787 
    return
8788 
 
8789 
 
3427 chandransh 8790 
  def __repr__(self):
8791 
    L = ['%s=%r' % (key, value)
8792 
      for key, value in self.__dict__.iteritems()]
8793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8794 
 
8795 
  def __eq__(self, other):
8796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8797 
 
8798 
  def __ne__(self, other):
8799 
    return not (self == other)
8800 
 
1382 varun.gupt 8801 
class getReturnableOrdersForCustomer_args:
8802 
  """
8803 
  Attributes:
8804 
   - customer_id
8805 
   - limit
8806 
  """
8807 
 
8808 
  thrift_spec = (
8809 
    None, # 0
8810 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8811 
    (2, TType.I64, 'limit', None, None, ), # 2
8812 
  )
8813 
 
8814 
  def __init__(self, customer_id=None, limit=None,):
8815 
    self.customer_id = customer_id
8816 
    self.limit = limit
8817 
 
8818 
  def read(self, iprot):
8819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8821 
      return
8822 
    iprot.readStructBegin()
8823 
    while True:
8824 
      (fname, ftype, fid) = iprot.readFieldBegin()
8825 
      if ftype == TType.STOP:
8826 
        break
8827 
      if fid == 1:
8828 
        if ftype == TType.I64:
8829 
          self.customer_id = iprot.readI64();
8830 
        else:
8831 
          iprot.skip(ftype)
8832 
      elif fid == 2:
8833 
        if ftype == TType.I64:
8834 
          self.limit = iprot.readI64();
8835 
        else:
8836 
          iprot.skip(ftype)
8837 
      else:
8838 
        iprot.skip(ftype)
8839 
      iprot.readFieldEnd()
8840 
    iprot.readStructEnd()
8841 
 
8842 
  def write(self, oprot):
8843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8845 
      return
8846 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8847 
    if self.customer_id is not None:
1382 varun.gupt 8848 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8849 
      oprot.writeI64(self.customer_id)
8850 
      oprot.writeFieldEnd()
3431 rajveer 8851 
    if self.limit is not None:
1382 varun.gupt 8852 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8853 
      oprot.writeI64(self.limit)
8854 
      oprot.writeFieldEnd()
8855 
    oprot.writeFieldStop()
8856 
    oprot.writeStructEnd()
8857 
 
3431 rajveer 8858 
  def validate(self):
8859 
    return
8860 
 
8861 
 
1382 varun.gupt 8862 
  def __repr__(self):
8863 
    L = ['%s=%r' % (key, value)
8864 
      for key, value in self.__dict__.iteritems()]
8865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8866 
 
8867 
  def __eq__(self, other):
8868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8869 
 
8870 
  def __ne__(self, other):
8871 
    return not (self == other)
8872 
 
8873 
class getReturnableOrdersForCustomer_result:
8874 
  """
8875 
  Attributes:
8876 
   - success
8877 
   - ex
8878 
  """
8879 
 
8880 
  thrift_spec = (
8881 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8883 
  )
8884 
 
8885 
  def __init__(self, success=None, ex=None,):
8886 
    self.success = success
8887 
    self.ex = ex
8888 
 
8889 
  def read(self, iprot):
8890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8892 
      return
8893 
    iprot.readStructBegin()
8894 
    while True:
8895 
      (fname, ftype, fid) = iprot.readFieldBegin()
8896 
      if ftype == TType.STOP:
8897 
        break
8898 
      if fid == 0:
8899 
        if ftype == TType.LIST:
8900 
          self.success = []
5031 varun.gupt 8901 
          (_etype129, _size126) = iprot.readListBegin()
8902 
          for _i130 in xrange(_size126):
8903 
            _elem131 = iprot.readI64();
8904 
            self.success.append(_elem131)
1382 varun.gupt 8905 
          iprot.readListEnd()
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      elif fid == 1:
8909 
        if ftype == TType.STRUCT:
8910 
          self.ex = TransactionServiceException()
8911 
          self.ex.read(iprot)
8912 
        else:
8913 
          iprot.skip(ftype)
8914 
      else:
8915 
        iprot.skip(ftype)
8916 
      iprot.readFieldEnd()
8917 
    iprot.readStructEnd()
8918 
 
8919 
  def write(self, oprot):
8920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8922 
      return
8923 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8924 
    if self.success is not None:
1382 varun.gupt 8925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8926 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8927 
      for iter132 in self.success:
8928 
        oprot.writeI64(iter132)
1382 varun.gupt 8929 
      oprot.writeListEnd()
8930 
      oprot.writeFieldEnd()
3431 rajveer 8931 
    if self.ex is not None:
1382 varun.gupt 8932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8933 
      self.ex.write(oprot)
8934 
      oprot.writeFieldEnd()
8935 
    oprot.writeFieldStop()
8936 
    oprot.writeStructEnd()
8937 
 
3431 rajveer 8938 
  def validate(self):
8939 
    return
8940 
 
8941 
 
1382 varun.gupt 8942 
  def __repr__(self):
8943 
    L = ['%s=%r' % (key, value)
8944 
      for key, value in self.__dict__.iteritems()]
8945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8946 
 
8947 
  def __eq__(self, other):
8948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8949 
 
8950 
  def __ne__(self, other):
8951 
    return not (self == other)
8952 
 
8953 
class getCancellableOrdersForCustomer_args:
8954 
  """
8955 
  Attributes:
8956 
   - customer_id
8957 
   - limit
8958 
  """
8959 
 
8960 
  thrift_spec = (
8961 
    None, # 0
8962 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8963 
    (2, TType.I64, 'limit', None, None, ), # 2
8964 
  )
8965 
 
8966 
  def __init__(self, customer_id=None, limit=None,):
8967 
    self.customer_id = customer_id
8968 
    self.limit = limit
8969 
 
8970 
  def read(self, iprot):
8971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8973 
      return
8974 
    iprot.readStructBegin()
8975 
    while True:
8976 
      (fname, ftype, fid) = iprot.readFieldBegin()
8977 
      if ftype == TType.STOP:
8978 
        break
8979 
      if fid == 1:
8980 
        if ftype == TType.I64:
8981 
          self.customer_id = iprot.readI64();
8982 
        else:
8983 
          iprot.skip(ftype)
8984 
      elif fid == 2:
8985 
        if ftype == TType.I64:
8986 
          self.limit = iprot.readI64();
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      else:
8990 
        iprot.skip(ftype)
8991 
      iprot.readFieldEnd()
8992 
    iprot.readStructEnd()
8993 
 
8994 
  def write(self, oprot):
8995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8997 
      return
8998 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8999 
    if self.customer_id is not None:
1382 varun.gupt 9000 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9001 
      oprot.writeI64(self.customer_id)
9002 
      oprot.writeFieldEnd()
3431 rajveer 9003 
    if self.limit is not None:
1382 varun.gupt 9004 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9005 
      oprot.writeI64(self.limit)
9006 
      oprot.writeFieldEnd()
9007 
    oprot.writeFieldStop()
9008 
    oprot.writeStructEnd()
9009 
 
3431 rajveer 9010 
  def validate(self):
9011 
    return
9012 
 
9013 
 
1382 varun.gupt 9014 
  def __repr__(self):
9015 
    L = ['%s=%r' % (key, value)
9016 
      for key, value in self.__dict__.iteritems()]
9017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9018 
 
9019 
  def __eq__(self, other):
9020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9021 
 
9022 
  def __ne__(self, other):
9023 
    return not (self == other)
9024 
 
9025 
class getCancellableOrdersForCustomer_result:
9026 
  """
9027 
  Attributes:
9028 
   - success
9029 
   - ex
9030 
  """
9031 
 
9032 
  thrift_spec = (
9033 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9034 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9035 
  )
9036 
 
9037 
  def __init__(self, success=None, ex=None,):
9038 
    self.success = success
9039 
    self.ex = ex
9040 
 
9041 
  def read(self, iprot):
9042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9044 
      return
9045 
    iprot.readStructBegin()
9046 
    while True:
9047 
      (fname, ftype, fid) = iprot.readFieldBegin()
9048 
      if ftype == TType.STOP:
9049 
        break
9050 
      if fid == 0:
9051 
        if ftype == TType.LIST:
9052 
          self.success = []
5031 varun.gupt 9053 
          (_etype136, _size133) = iprot.readListBegin()
9054 
          for _i137 in xrange(_size133):
9055 
            _elem138 = iprot.readI64();
9056 
            self.success.append(_elem138)
1382 varun.gupt 9057 
          iprot.readListEnd()
9058 
        else:
9059 
          iprot.skip(ftype)
9060 
      elif fid == 1:
9061 
        if ftype == TType.STRUCT:
9062 
          self.ex = TransactionServiceException()
9063 
          self.ex.read(iprot)
9064 
        else:
9065 
          iprot.skip(ftype)
9066 
      else:
9067 
        iprot.skip(ftype)
9068 
      iprot.readFieldEnd()
9069 
    iprot.readStructEnd()
9070 
 
9071 
  def write(self, oprot):
9072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9074 
      return
9075 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9076 
    if self.success is not None:
1382 varun.gupt 9077 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9078 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9079 
      for iter139 in self.success:
9080 
        oprot.writeI64(iter139)
1382 varun.gupt 9081 
      oprot.writeListEnd()
9082 
      oprot.writeFieldEnd()
3431 rajveer 9083 
    if self.ex is not None:
1382 varun.gupt 9084 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9085 
      self.ex.write(oprot)
9086 
      oprot.writeFieldEnd()
9087 
    oprot.writeFieldStop()
9088 
    oprot.writeStructEnd()
9089 
 
3431 rajveer 9090 
  def validate(self):
9091 
    return
9092 
 
9093 
 
1382 varun.gupt 9094 
  def __repr__(self):
9095 
    L = ['%s=%r' % (key, value)
9096 
      for key, value in self.__dict__.iteritems()]
9097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9098 
 
9099 
  def __eq__(self, other):
9100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9101 
 
9102 
  def __ne__(self, other):
9103 
    return not (self == other)
9104 
 
483 rajveer 9105 
class changeOrderStatus_args:
94 ashish 9106 
  """
9107 
  Attributes:
483 rajveer 9108 
   - orderId
9109 
   - status
9110 
   - description
94 ashish 9111 
  """
9112 
 
9113 
  thrift_spec = (
9114 
    None, # 0
483 rajveer 9115 
    (1, TType.I64, 'orderId', None, None, ), # 1
9116 
    (2, TType.I32, 'status', None, None, ), # 2
9117 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9118 
  )
9119 
 
483 rajveer 9120 
  def __init__(self, orderId=None, status=None, description=None,):
9121 
    self.orderId = orderId
9122 
    self.status = status
9123 
    self.description = description
94 ashish 9124 
 
9125 
  def read(self, iprot):
9126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9128 
      return
9129 
    iprot.readStructBegin()
9130 
    while True:
9131 
      (fname, ftype, fid) = iprot.readFieldBegin()
9132 
      if ftype == TType.STOP:
9133 
        break
9134 
      if fid == 1:
9135 
        if ftype == TType.I64:
483 rajveer 9136 
          self.orderId = iprot.readI64();
94 ashish 9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      elif fid == 2:
483 rajveer 9140 
        if ftype == TType.I32:
9141 
          self.status = iprot.readI32();
94 ashish 9142 
        else:
9143 
          iprot.skip(ftype)
483 rajveer 9144 
      elif fid == 3:
9145 
        if ftype == TType.STRING:
9146 
          self.description = iprot.readString();
9147 
        else:
9148 
          iprot.skip(ftype)
94 ashish 9149 
      else:
9150 
        iprot.skip(ftype)
9151 
      iprot.readFieldEnd()
9152 
    iprot.readStructEnd()
9153 
 
9154 
  def write(self, oprot):
9155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9157 
      return
483 rajveer 9158 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9159 
    if self.orderId is not None:
483 rajveer 9160 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9161 
      oprot.writeI64(self.orderId)
94 ashish 9162 
      oprot.writeFieldEnd()
3431 rajveer 9163 
    if self.status is not None:
483 rajveer 9164 
      oprot.writeFieldBegin('status', TType.I32, 2)
9165 
      oprot.writeI32(self.status)
94 ashish 9166 
      oprot.writeFieldEnd()
3431 rajveer 9167 
    if self.description is not None:
483 rajveer 9168 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9169 
      oprot.writeString(self.description)
9170 
      oprot.writeFieldEnd()
94 ashish 9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
3431 rajveer 9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
94 ashish 9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
483 rajveer 9189 
class changeOrderStatus_result:
94 ashish 9190 
  """
9191 
  Attributes:
9192 
   - success
9193 
   - ex
9194 
  """
9195 
 
9196 
  thrift_spec = (
9197 
    (0, TType.BOOL, 'success', None, None, ), # 0
9198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9199 
  )
9200 
 
9201 
  def __init__(self, success=None, ex=None,):
9202 
    self.success = success
9203 
    self.ex = ex
9204 
 
9205 
  def read(self, iprot):
9206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9208 
      return
9209 
    iprot.readStructBegin()
9210 
    while True:
9211 
      (fname, ftype, fid) = iprot.readFieldBegin()
9212 
      if ftype == TType.STOP:
9213 
        break
9214 
      if fid == 0:
9215 
        if ftype == TType.BOOL:
9216 
          self.success = iprot.readBool();
9217 
        else:
9218 
          iprot.skip(ftype)
9219 
      elif fid == 1:
9220 
        if ftype == TType.STRUCT:
9221 
          self.ex = TransactionServiceException()
9222 
          self.ex.read(iprot)
9223 
        else:
9224 
          iprot.skip(ftype)
9225 
      else:
9226 
        iprot.skip(ftype)
9227 
      iprot.readFieldEnd()
9228 
    iprot.readStructEnd()
9229 
 
9230 
  def write(self, oprot):
9231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9233 
      return
483 rajveer 9234 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9235 
    if self.success is not None:
94 ashish 9236 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9237 
      oprot.writeBool(self.success)
9238 
      oprot.writeFieldEnd()
3431 rajveer 9239 
    if self.ex is not None:
94 ashish 9240 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9241 
      self.ex.write(oprot)
9242 
      oprot.writeFieldEnd()
9243 
    oprot.writeFieldStop()
9244 
    oprot.writeStructEnd()
9245 
 
3431 rajveer 9246 
  def validate(self):
9247 
    return
9248 
 
9249 
 
94 ashish 9250 
  def __repr__(self):
9251 
    L = ['%s=%r' % (key, value)
9252 
      for key, value in self.__dict__.iteritems()]
9253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9254 
 
9255 
  def __eq__(self, other):
9256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9257 
 
9258 
  def __ne__(self, other):
9259 
    return not (self == other)
9260 
 
3064 chandransh 9261 
class getOrdersForTransaction_args:
494 rajveer 9262 
  """
9263 
  Attributes:
3064 chandransh 9264 
   - transactionId
9265 
   - customerId
494 rajveer 9266 
  """
9267 
 
9268 
  thrift_spec = (
9269 
    None, # 0
3064 chandransh 9270 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9271 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9272 
  )
9273 
 
3064 chandransh 9274 
  def __init__(self, transactionId=None, customerId=None,):
9275 
    self.transactionId = transactionId
9276 
    self.customerId = customerId
494 rajveer 9277 
 
9278 
  def read(self, iprot):
9279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9281 
      return
9282 
    iprot.readStructBegin()
9283 
    while True:
9284 
      (fname, ftype, fid) = iprot.readFieldBegin()
9285 
      if ftype == TType.STOP:
9286 
        break
9287 
      if fid == 1:
9288 
        if ftype == TType.I64:
3064 chandransh 9289 
          self.transactionId = iprot.readI64();
494 rajveer 9290 
        else:
9291 
          iprot.skip(ftype)
9292 
      elif fid == 2:
3064 chandransh 9293 
        if ftype == TType.I64:
9294 
          self.customerId = iprot.readI64();
494 rajveer 9295 
        else:
9296 
          iprot.skip(ftype)
9297 
      else:
9298 
        iprot.skip(ftype)
9299 
      iprot.readFieldEnd()
9300 
    iprot.readStructEnd()
9301 
 
9302 
  def write(self, oprot):
9303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9305 
      return
3064 chandransh 9306 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9307 
    if self.transactionId is not None:
3064 chandransh 9308 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9309 
      oprot.writeI64(self.transactionId)
494 rajveer 9310 
      oprot.writeFieldEnd()
3431 rajveer 9311 
    if self.customerId is not None:
3064 chandransh 9312 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9313 
      oprot.writeI64(self.customerId)
494 rajveer 9314 
      oprot.writeFieldEnd()
9315 
    oprot.writeFieldStop()
9316 
    oprot.writeStructEnd()
9317 
 
3431 rajveer 9318 
  def validate(self):
9319 
    return
9320 
 
9321 
 
494 rajveer 9322 
  def __repr__(self):
9323 
    L = ['%s=%r' % (key, value)
9324 
      for key, value in self.__dict__.iteritems()]
9325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9326 
 
9327 
  def __eq__(self, other):
9328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9329 
 
9330 
  def __ne__(self, other):
9331 
    return not (self == other)
9332 
 
3064 chandransh 9333 
class getOrdersForTransaction_result:
494 rajveer 9334 
  """
9335 
  Attributes:
9336 
   - success
9337 
   - ex
9338 
  """
9339 
 
9340 
  thrift_spec = (
3064 chandransh 9341 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9343 
  )
9344 
 
9345 
  def __init__(self, success=None, ex=None,):
9346 
    self.success = success
9347 
    self.ex = ex
9348 
 
9349 
  def read(self, iprot):
9350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9352 
      return
9353 
    iprot.readStructBegin()
9354 
    while True:
9355 
      (fname, ftype, fid) = iprot.readFieldBegin()
9356 
      if ftype == TType.STOP:
9357 
        break
9358 
      if fid == 0:
3064 chandransh 9359 
        if ftype == TType.LIST:
9360 
          self.success = []
5031 varun.gupt 9361 
          (_etype143, _size140) = iprot.readListBegin()
9362 
          for _i144 in xrange(_size140):
9363 
            _elem145 = Order()
9364 
            _elem145.read(iprot)
9365 
            self.success.append(_elem145)
3064 chandransh 9366 
          iprot.readListEnd()
494 rajveer 9367 
        else:
9368 
          iprot.skip(ftype)
9369 
      elif fid == 1:
9370 
        if ftype == TType.STRUCT:
9371 
          self.ex = TransactionServiceException()
9372 
          self.ex.read(iprot)
9373 
        else:
9374 
          iprot.skip(ftype)
9375 
      else:
9376 
        iprot.skip(ftype)
9377 
      iprot.readFieldEnd()
9378 
    iprot.readStructEnd()
9379 
 
9380 
  def write(self, oprot):
9381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9383 
      return
3064 chandransh 9384 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9385 
    if self.success is not None:
3064 chandransh 9386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9388 
      for iter146 in self.success:
9389 
        iter146.write(oprot)
3064 chandransh 9390 
      oprot.writeListEnd()
494 rajveer 9391 
      oprot.writeFieldEnd()
3431 rajveer 9392 
    if self.ex is not None:
494 rajveer 9393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9394 
      self.ex.write(oprot)
9395 
      oprot.writeFieldEnd()
9396 
    oprot.writeFieldStop()
9397 
    oprot.writeStructEnd()
9398 
 
3431 rajveer 9399 
  def validate(self):
9400 
    return
9401 
 
9402 
 
494 rajveer 9403 
  def __repr__(self):
9404 
    L = ['%s=%r' % (key, value)
9405 
      for key, value in self.__dict__.iteritems()]
9406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9407 
 
9408 
  def __eq__(self, other):
9409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9410 
 
9411 
  def __ne__(self, other):
9412 
    return not (self == other)
9413 
 
3064 chandransh 9414 
class getOrdersForCustomer_args:
1149 chandransh 9415 
  """
9416 
  Attributes:
3064 chandransh 9417 
   - customerId
9418 
   - from_date
9419 
   - to_date
9420 
   - statuses
1149 chandransh 9421 
  """
9422 
 
9423 
  thrift_spec = (
9424 
    None, # 0
3064 chandransh 9425 
    (1, TType.I64, 'customerId', None, None, ), # 1
9426 
    (2, TType.I64, 'from_date', None, None, ), # 2
9427 
    (3, TType.I64, 'to_date', None, None, ), # 3
9428 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9429 
  )
9430 
 
3064 chandransh 9431 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9432 
    self.customerId = customerId
9433 
    self.from_date = from_date
9434 
    self.to_date = to_date
9435 
    self.statuses = statuses
1149 chandransh 9436 
 
9437 
  def read(self, iprot):
9438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9440 
      return
9441 
    iprot.readStructBegin()
9442 
    while True:
9443 
      (fname, ftype, fid) = iprot.readFieldBegin()
9444 
      if ftype == TType.STOP:
9445 
        break
9446 
      if fid == 1:
9447 
        if ftype == TType.I64:
3064 chandransh 9448 
          self.customerId = iprot.readI64();
1149 chandransh 9449 
        else:
9450 
          iprot.skip(ftype)
9451 
      elif fid == 2:
9452 
        if ftype == TType.I64:
3064 chandransh 9453 
          self.from_date = iprot.readI64();
1149 chandransh 9454 
        else:
9455 
          iprot.skip(ftype)
2783 chandransh 9456 
      elif fid == 3:
9457 
        if ftype == TType.I64:
3064 chandransh 9458 
          self.to_date = iprot.readI64();
2783 chandransh 9459 
        else:
9460 
          iprot.skip(ftype)
9461 
      elif fid == 4:
3064 chandransh 9462 
        if ftype == TType.LIST:
9463 
          self.statuses = []
5031 varun.gupt 9464 
          (_etype150, _size147) = iprot.readListBegin()
9465 
          for _i151 in xrange(_size147):
9466 
            _elem152 = iprot.readI32();
9467 
            self.statuses.append(_elem152)
3064 chandransh 9468 
          iprot.readListEnd()
2783 chandransh 9469 
        else:
9470 
          iprot.skip(ftype)
1149 chandransh 9471 
      else:
9472 
        iprot.skip(ftype)
9473 
      iprot.readFieldEnd()
9474 
    iprot.readStructEnd()
9475 
 
9476 
  def write(self, oprot):
9477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9479 
      return
3064 chandransh 9480 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9481 
    if self.customerId is not None:
3064 chandransh 9482 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9483 
      oprot.writeI64(self.customerId)
1149 chandransh 9484 
      oprot.writeFieldEnd()
3431 rajveer 9485 
    if self.from_date is not None:
3064 chandransh 9486 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9487 
      oprot.writeI64(self.from_date)
1149 chandransh 9488 
      oprot.writeFieldEnd()
3431 rajveer 9489 
    if self.to_date is not None:
3064 chandransh 9490 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9491 
      oprot.writeI64(self.to_date)
2783 chandransh 9492 
      oprot.writeFieldEnd()
3431 rajveer 9493 
    if self.statuses is not None:
3064 chandransh 9494 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9495 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9496 
      for iter153 in self.statuses:
9497 
        oprot.writeI32(iter153)
3064 chandransh 9498 
      oprot.writeListEnd()
2783 chandransh 9499 
      oprot.writeFieldEnd()
1149 chandransh 9500 
    oprot.writeFieldStop()
9501 
    oprot.writeStructEnd()
9502 
 
3431 rajveer 9503 
  def validate(self):
9504 
    return
9505 
 
9506 
 
1149 chandransh 9507 
  def __repr__(self):
9508 
    L = ['%s=%r' % (key, value)
9509 
      for key, value in self.__dict__.iteritems()]
9510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9511 
 
9512 
  def __eq__(self, other):
9513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9514 
 
9515 
  def __ne__(self, other):
9516 
    return not (self == other)
9517 
 
3064 chandransh 9518 
class getOrdersForCustomer_result:
1149 chandransh 9519 
  """
9520 
  Attributes:
9521 
   - success
9522 
   - ex
9523 
  """
9524 
 
9525 
  thrift_spec = (
3064 chandransh 9526 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9528 
  )
9529 
 
9530 
  def __init__(self, success=None, ex=None,):
9531 
    self.success = success
9532 
    self.ex = ex
9533 
 
9534 
  def read(self, iprot):
9535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9537 
      return
9538 
    iprot.readStructBegin()
9539 
    while True:
9540 
      (fname, ftype, fid) = iprot.readFieldBegin()
9541 
      if ftype == TType.STOP:
9542 
        break
9543 
      if fid == 0:
3064 chandransh 9544 
        if ftype == TType.LIST:
9545 
          self.success = []
5031 varun.gupt 9546 
          (_etype157, _size154) = iprot.readListBegin()
9547 
          for _i158 in xrange(_size154):
9548 
            _elem159 = Order()
9549 
            _elem159.read(iprot)
9550 
            self.success.append(_elem159)
3064 chandransh 9551 
          iprot.readListEnd()
1149 chandransh 9552 
        else:
9553 
          iprot.skip(ftype)
9554 
      elif fid == 1:
9555 
        if ftype == TType.STRUCT:
9556 
          self.ex = TransactionServiceException()
9557 
          self.ex.read(iprot)
9558 
        else:
9559 
          iprot.skip(ftype)
9560 
      else:
9561 
        iprot.skip(ftype)
9562 
      iprot.readFieldEnd()
9563 
    iprot.readStructEnd()
9564 
 
9565 
  def write(self, oprot):
9566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9568 
      return
3064 chandransh 9569 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9570 
    if self.success is not None:
3064 chandransh 9571 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9572 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9573 
      for iter160 in self.success:
9574 
        iter160.write(oprot)
3064 chandransh 9575 
      oprot.writeListEnd()
1149 chandransh 9576 
      oprot.writeFieldEnd()
3431 rajveer 9577 
    if self.ex is not None:
1149 chandransh 9578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9579 
      self.ex.write(oprot)
9580 
      oprot.writeFieldEnd()
9581 
    oprot.writeFieldStop()
9582 
    oprot.writeStructEnd()
9583 
 
3431 rajveer 9584 
  def validate(self):
9585 
    return
9586 
 
9587 
 
1149 chandransh 9588 
  def __repr__(self):
9589 
    L = ['%s=%r' % (key, value)
9590 
      for key, value in self.__dict__.iteritems()]
9591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9592 
 
9593 
  def __eq__(self, other):
9594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9595 
 
9596 
  def __ne__(self, other):
9597 
    return not (self == other)
9598 
 
3064 chandransh 9599 
class createOrder_args:
921 rajveer 9600 
  """
9601 
  Attributes:
3064 chandransh 9602 
   - order
921 rajveer 9603 
  """
9604 
 
9605 
  thrift_spec = (
9606 
    None, # 0
3064 chandransh 9607 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9608 
  )
9609 
 
3064 chandransh 9610 
  def __init__(self, order=None,):
9611 
    self.order = order
921 rajveer 9612 
 
9613 
  def read(self, iprot):
9614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9616 
      return
9617 
    iprot.readStructBegin()
9618 
    while True:
9619 
      (fname, ftype, fid) = iprot.readFieldBegin()
9620 
      if ftype == TType.STOP:
9621 
        break
9622 
      if fid == 1:
3064 chandransh 9623 
        if ftype == TType.STRUCT:
9624 
          self.order = Order()
9625 
          self.order.read(iprot)
921 rajveer 9626 
        else:
9627 
          iprot.skip(ftype)
9628 
      else:
9629 
        iprot.skip(ftype)
9630 
      iprot.readFieldEnd()
9631 
    iprot.readStructEnd()
9632 
 
9633 
  def write(self, oprot):
9634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9636 
      return
3064 chandransh 9637 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9638 
    if self.order is not None:
3064 chandransh 9639 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9640 
      self.order.write(oprot)
921 rajveer 9641 
      oprot.writeFieldEnd()
9642 
    oprot.writeFieldStop()
9643 
    oprot.writeStructEnd()
9644 
 
3431 rajveer 9645 
  def validate(self):
9646 
    return
9647 
 
9648 
 
921 rajveer 9649 
  def __repr__(self):
9650 
    L = ['%s=%r' % (key, value)
9651 
      for key, value in self.__dict__.iteritems()]
9652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9653 
 
9654 
  def __eq__(self, other):
9655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9656 
 
9657 
  def __ne__(self, other):
9658 
    return not (self == other)
9659 
 
3064 chandransh 9660 
class createOrder_result:
921 rajveer 9661 
  """
9662 
  Attributes:
9663 
   - success
9664 
   - ex
9665 
  """
9666 
 
9667 
  thrift_spec = (
3064 chandransh 9668 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9670 
  )
9671 
 
9672 
  def __init__(self, success=None, ex=None,):
9673 
    self.success = success
9674 
    self.ex = ex
9675 
 
9676 
  def read(self, iprot):
9677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9679 
      return
9680 
    iprot.readStructBegin()
9681 
    while True:
9682 
      (fname, ftype, fid) = iprot.readFieldBegin()
9683 
      if ftype == TType.STOP:
9684 
        break
9685 
      if fid == 0:
3064 chandransh 9686 
        if ftype == TType.I64:
9687 
          self.success = iprot.readI64();
921 rajveer 9688 
        else:
9689 
          iprot.skip(ftype)
9690 
      elif fid == 1:
9691 
        if ftype == TType.STRUCT:
9692 
          self.ex = TransactionServiceException()
9693 
          self.ex.read(iprot)
9694 
        else:
9695 
          iprot.skip(ftype)
9696 
      else:
9697 
        iprot.skip(ftype)
9698 
      iprot.readFieldEnd()
9699 
    iprot.readStructEnd()
9700 
 
9701 
  def write(self, oprot):
9702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9704 
      return
3064 chandransh 9705 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9706 
    if self.success is not None:
3064 chandransh 9707 
      oprot.writeFieldBegin('success', TType.I64, 0)
9708 
      oprot.writeI64(self.success)
921 rajveer 9709 
      oprot.writeFieldEnd()
3431 rajveer 9710 
    if self.ex is not None:
921 rajveer 9711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9712 
      self.ex.write(oprot)
9713 
      oprot.writeFieldEnd()
9714 
    oprot.writeFieldStop()
9715 
    oprot.writeStructEnd()
9716 
 
3431 rajveer 9717 
  def validate(self):
9718 
    return
9719 
 
9720 
 
921 rajveer 9721 
  def __repr__(self):
9722 
    L = ['%s=%r' % (key, value)
9723 
      for key, value in self.__dict__.iteritems()]
9724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9725 
 
9726 
  def __eq__(self, other):
9727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9728 
 
9729 
  def __ne__(self, other):
9730 
    return not (self == other)
9731 
 
3064 chandransh 9732 
class getOrder_args:
921 rajveer 9733 
  """
9734 
  Attributes:
3064 chandransh 9735 
   - id
921 rajveer 9736 
  """
9737 
 
9738 
  thrift_spec = (
9739 
    None, # 0
3064 chandransh 9740 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9741 
  )
9742 
 
3064 chandransh 9743 
  def __init__(self, id=None,):
9744 
    self.id = id
921 rajveer 9745 
 
9746 
  def read(self, iprot):
9747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9749 
      return
9750 
    iprot.readStructBegin()
9751 
    while True:
9752 
      (fname, ftype, fid) = iprot.readFieldBegin()
9753 
      if ftype == TType.STOP:
9754 
        break
9755 
      if fid == 1:
9756 
        if ftype == TType.I64:
3064 chandransh 9757 
          self.id = iprot.readI64();
921 rajveer 9758 
        else:
9759 
          iprot.skip(ftype)
9760 
      else:
9761 
        iprot.skip(ftype)
9762 
      iprot.readFieldEnd()
9763 
    iprot.readStructEnd()
9764 
 
9765 
  def write(self, oprot):
9766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9768 
      return
3064 chandransh 9769 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9770 
    if self.id is not None:
3064 chandransh 9771 
      oprot.writeFieldBegin('id', TType.I64, 1)
9772 
      oprot.writeI64(self.id)
921 rajveer 9773 
      oprot.writeFieldEnd()
9774 
    oprot.writeFieldStop()
9775 
    oprot.writeStructEnd()
9776 
 
3431 rajveer 9777 
  def validate(self):
9778 
    return
9779 
 
9780 
 
921 rajveer 9781 
  def __repr__(self):
9782 
    L = ['%s=%r' % (key, value)
9783 
      for key, value in self.__dict__.iteritems()]
9784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9785 
 
9786 
  def __eq__(self, other):
9787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9788 
 
9789 
  def __ne__(self, other):
9790 
    return not (self == other)
9791 
 
3064 chandransh 9792 
class getOrder_result:
921 rajveer 9793 
  """
9794 
  Attributes:
9795 
   - success
9796 
   - ex
9797 
  """
9798 
 
9799 
  thrift_spec = (
3064 chandransh 9800 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9802 
  )
9803 
 
9804 
  def __init__(self, success=None, ex=None,):
9805 
    self.success = success
9806 
    self.ex = ex
9807 
 
9808 
  def read(self, iprot):
9809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9811 
      return
9812 
    iprot.readStructBegin()
9813 
    while True:
9814 
      (fname, ftype, fid) = iprot.readFieldBegin()
9815 
      if ftype == TType.STOP:
9816 
        break
9817 
      if fid == 0:
3064 chandransh 9818 
        if ftype == TType.STRUCT:
9819 
          self.success = Order()
9820 
          self.success.read(iprot)
921 rajveer 9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      elif fid == 1:
9824 
        if ftype == TType.STRUCT:
9825 
          self.ex = TransactionServiceException()
9826 
          self.ex.read(iprot)
9827 
        else:
9828 
          iprot.skip(ftype)
9829 
      else:
9830 
        iprot.skip(ftype)
9831 
      iprot.readFieldEnd()
9832 
    iprot.readStructEnd()
9833 
 
9834 
  def write(self, oprot):
9835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9837 
      return
3064 chandransh 9838 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9839 
    if self.success is not None:
3064 chandransh 9840 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9841 
      self.success.write(oprot)
921 rajveer 9842 
      oprot.writeFieldEnd()
3431 rajveer 9843 
    if self.ex is not None:
921 rajveer 9844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9845 
      self.ex.write(oprot)
9846 
      oprot.writeFieldEnd()
9847 
    oprot.writeFieldStop()
9848 
    oprot.writeStructEnd()
9849 
 
3431 rajveer 9850 
  def validate(self):
9851 
    return
9852 
 
9853 
 
921 rajveer 9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
3064 chandransh 9865 
class getLineItemsForOrder_args:
94 ashish 9866 
  """
9867 
  Attributes:
3064 chandransh 9868 
   - orderId
94 ashish 9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    None, # 0
3064 chandransh 9873 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9874 
  )
9875 
 
3064 chandransh 9876 
  def __init__(self, orderId=None,):
9877 
    self.orderId = orderId
94 ashish 9878 
 
9879 
  def read(self, iprot):
9880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9882 
      return
9883 
    iprot.readStructBegin()
9884 
    while True:
9885 
      (fname, ftype, fid) = iprot.readFieldBegin()
9886 
      if ftype == TType.STOP:
9887 
        break
9888 
      if fid == 1:
9889 
        if ftype == TType.I64:
3064 chandransh 9890 
          self.orderId = iprot.readI64();
94 ashish 9891 
        else:
9892 
          iprot.skip(ftype)
9893 
      else:
9894 
        iprot.skip(ftype)
9895 
      iprot.readFieldEnd()
9896 
    iprot.readStructEnd()
9897 
 
9898 
  def write(self, oprot):
9899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9901 
      return
3064 chandransh 9902 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9903 
    if self.orderId is not None:
3064 chandransh 9904 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9905 
      oprot.writeI64(self.orderId)
94 ashish 9906 
      oprot.writeFieldEnd()
9907 
    oprot.writeFieldStop()
9908 
    oprot.writeStructEnd()
9909 
 
3431 rajveer 9910 
  def validate(self):
9911 
    return
9912 
 
9913 
 
94 ashish 9914 
  def __repr__(self):
9915 
    L = ['%s=%r' % (key, value)
9916 
      for key, value in self.__dict__.iteritems()]
9917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9918 
 
9919 
  def __eq__(self, other):
9920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9921 
 
9922 
  def __ne__(self, other):
9923 
    return not (self == other)
9924 
 
3064 chandransh 9925 
class getLineItemsForOrder_result:
94 ashish 9926 
  """
9927 
  Attributes:
9928 
   - success
9929 
   - ex
9930 
  """
9931 
 
9932 
  thrift_spec = (
3064 chandransh 9933 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9935 
  )
9936 
 
9937 
  def __init__(self, success=None, ex=None,):
9938 
    self.success = success
9939 
    self.ex = ex
9940 
 
9941 
  def read(self, iprot):
9942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9944 
      return
9945 
    iprot.readStructBegin()
9946 
    while True:
9947 
      (fname, ftype, fid) = iprot.readFieldBegin()
9948 
      if ftype == TType.STOP:
9949 
        break
9950 
      if fid == 0:
483 rajveer 9951 
        if ftype == TType.LIST:
9952 
          self.success = []
5031 varun.gupt 9953 
          (_etype164, _size161) = iprot.readListBegin()
9954 
          for _i165 in xrange(_size161):
9955 
            _elem166 = LineItem()
9956 
            _elem166.read(iprot)
9957 
            self.success.append(_elem166)
483 rajveer 9958 
          iprot.readListEnd()
94 ashish 9959 
        else:
9960 
          iprot.skip(ftype)
9961 
      elif fid == 1:
9962 
        if ftype == TType.STRUCT:
9963 
          self.ex = TransactionServiceException()
9964 
          self.ex.read(iprot)
9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      else:
9968 
        iprot.skip(ftype)
9969 
      iprot.readFieldEnd()
9970 
    iprot.readStructEnd()
9971 
 
9972 
  def write(self, oprot):
9973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9975 
      return
3064 chandransh 9976 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9977 
    if self.success is not None:
483 rajveer 9978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9980 
      for iter167 in self.success:
9981 
        iter167.write(oprot)
483 rajveer 9982 
      oprot.writeListEnd()
94 ashish 9983 
      oprot.writeFieldEnd()
3431 rajveer 9984 
    if self.ex is not None:
94 ashish 9985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9986 
      self.ex.write(oprot)
9987 
      oprot.writeFieldEnd()
9988 
    oprot.writeFieldStop()
9989 
    oprot.writeStructEnd()
9990 
 
3431 rajveer 9991 
  def validate(self):
9992 
    return
9993 
 
9994 
 
94 ashish 9995 
  def __repr__(self):
9996 
    L = ['%s=%r' % (key, value)
9997 
      for key, value in self.__dict__.iteritems()]
9998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9999 
 
10000 
  def __eq__(self, other):
10001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10002 
 
10003 
  def __ne__(self, other):
10004 
    return not (self == other)
10005 
 
4999 phani.kuma 10006 
class getOrderList_args:
10007 
  """
10008 
  Attributes:
10009 
   - order_ids
10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    None, # 0
10014 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10015 
  )
10016 
 
10017 
  def __init__(self, order_ids=None,):
10018 
    self.order_ids = order_ids
10019 
 
10020 
  def read(self, iprot):
10021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10023 
      return
10024 
    iprot.readStructBegin()
10025 
    while True:
10026 
      (fname, ftype, fid) = iprot.readFieldBegin()
10027 
      if ftype == TType.STOP:
10028 
        break
10029 
      if fid == 1:
10030 
        if ftype == TType.LIST:
10031 
          self.order_ids = []
5031 varun.gupt 10032 
          (_etype171, _size168) = iprot.readListBegin()
10033 
          for _i172 in xrange(_size168):
10034 
            _elem173 = iprot.readI64();
10035 
            self.order_ids.append(_elem173)
4999 phani.kuma 10036 
          iprot.readListEnd()
10037 
        else:
10038 
          iprot.skip(ftype)
10039 
      else:
10040 
        iprot.skip(ftype)
10041 
      iprot.readFieldEnd()
10042 
    iprot.readStructEnd()
10043 
 
10044 
  def write(self, oprot):
10045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10047 
      return
10048 
    oprot.writeStructBegin('getOrderList_args')
10049 
    if self.order_ids is not None:
10050 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10051 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10052 
      for iter174 in self.order_ids:
10053 
        oprot.writeI64(iter174)
4999 phani.kuma 10054 
      oprot.writeListEnd()
10055 
      oprot.writeFieldEnd()
10056 
    oprot.writeFieldStop()
10057 
    oprot.writeStructEnd()
10058 
 
10059 
  def validate(self):
10060 
    return
10061 
 
10062 
 
10063 
  def __repr__(self):
10064 
    L = ['%s=%r' % (key, value)
10065 
      for key, value in self.__dict__.iteritems()]
10066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10067 
 
10068 
  def __eq__(self, other):
10069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10070 
 
10071 
  def __ne__(self, other):
10072 
    return not (self == other)
10073 
 
10074 
class getOrderList_result:
10075 
  """
10076 
  Attributes:
10077 
   - success
10078 
  """
10079 
 
10080 
  thrift_spec = (
10081 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10082 
  )
10083 
 
10084 
  def __init__(self, success=None,):
10085 
    self.success = success
10086 
 
10087 
  def read(self, iprot):
10088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10090 
      return
10091 
    iprot.readStructBegin()
10092 
    while True:
10093 
      (fname, ftype, fid) = iprot.readFieldBegin()
10094 
      if ftype == TType.STOP:
10095 
        break
10096 
      if fid == 0:
10097 
        if ftype == TType.LIST:
10098 
          self.success = []
5031 varun.gupt 10099 
          (_etype178, _size175) = iprot.readListBegin()
10100 
          for _i179 in xrange(_size175):
10101 
            _elem180 = Order()
10102 
            _elem180.read(iprot)
10103 
            self.success.append(_elem180)
4999 phani.kuma 10104 
          iprot.readListEnd()
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      else:
10108 
        iprot.skip(ftype)
10109 
      iprot.readFieldEnd()
10110 
    iprot.readStructEnd()
10111 
 
10112 
  def write(self, oprot):
10113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10115 
      return
10116 
    oprot.writeStructBegin('getOrderList_result')
10117 
    if self.success is not None:
10118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10120 
      for iter181 in self.success:
10121 
        iter181.write(oprot)
4999 phani.kuma 10122 
      oprot.writeListEnd()
10123 
      oprot.writeFieldEnd()
10124 
    oprot.writeFieldStop()
10125 
    oprot.writeStructEnd()
10126 
 
10127 
  def validate(self):
10128 
    return
10129 
 
10130 
 
10131 
  def __repr__(self):
10132 
    L = ['%s=%r' % (key, value)
10133 
      for key, value in self.__dict__.iteritems()]
10134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10135 
 
10136 
  def __eq__(self, other):
10137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10138 
 
10139 
  def __ne__(self, other):
10140 
    return not (self == other)
10141 
 
5386 phani.kuma 10142 
class getOrderListForVendor_args:
10143 
  """
10144 
  Attributes:
10145 
   - order_ids
10146 
   - vendorId
10147 
  """
10148 
 
10149 
  thrift_spec = (
10150 
    None, # 0
10151 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10152 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10153 
  )
10154 
 
10155 
  def __init__(self, order_ids=None, vendorId=None,):
10156 
    self.order_ids = order_ids
10157 
    self.vendorId = vendorId
10158 
 
10159 
  def read(self, iprot):
10160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10162 
      return
10163 
    iprot.readStructBegin()
10164 
    while True:
10165 
      (fname, ftype, fid) = iprot.readFieldBegin()
10166 
      if ftype == TType.STOP:
10167 
        break
10168 
      if fid == 1:
10169 
        if ftype == TType.LIST:
10170 
          self.order_ids = []
10171 
          (_etype185, _size182) = iprot.readListBegin()
10172 
          for _i186 in xrange(_size182):
10173 
            _elem187 = iprot.readI64();
10174 
            self.order_ids.append(_elem187)
10175 
          iprot.readListEnd()
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      elif fid == 2:
10179 
        if ftype == TType.I64:
10180 
          self.vendorId = iprot.readI64();
10181 
        else:
10182 
          iprot.skip(ftype)
10183 
      else:
10184 
        iprot.skip(ftype)
10185 
      iprot.readFieldEnd()
10186 
    iprot.readStructEnd()
10187 
 
10188 
  def write(self, oprot):
10189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10191 
      return
10192 
    oprot.writeStructBegin('getOrderListForVendor_args')
10193 
    if self.order_ids is not None:
10194 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10195 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10196 
      for iter188 in self.order_ids:
10197 
        oprot.writeI64(iter188)
10198 
      oprot.writeListEnd()
10199 
      oprot.writeFieldEnd()
10200 
    if self.vendorId is not None:
10201 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10202 
      oprot.writeI64(self.vendorId)
10203 
      oprot.writeFieldEnd()
10204 
    oprot.writeFieldStop()
10205 
    oprot.writeStructEnd()
10206 
 
10207 
  def validate(self):
10208 
    return
10209 
 
10210 
 
10211 
  def __repr__(self):
10212 
    L = ['%s=%r' % (key, value)
10213 
      for key, value in self.__dict__.iteritems()]
10214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10215 
 
10216 
  def __eq__(self, other):
10217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10218 
 
10219 
  def __ne__(self, other):
10220 
    return not (self == other)
10221 
 
10222 
class getOrderListForVendor_result:
10223 
  """
10224 
  Attributes:
10225 
   - success
10226 
  """
10227 
 
10228 
  thrift_spec = (
10229 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10230 
  )
10231 
 
10232 
  def __init__(self, success=None,):
10233 
    self.success = success
10234 
 
10235 
  def read(self, iprot):
10236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10238 
      return
10239 
    iprot.readStructBegin()
10240 
    while True:
10241 
      (fname, ftype, fid) = iprot.readFieldBegin()
10242 
      if ftype == TType.STOP:
10243 
        break
10244 
      if fid == 0:
10245 
        if ftype == TType.LIST:
10246 
          self.success = []
10247 
          (_etype192, _size189) = iprot.readListBegin()
10248 
          for _i193 in xrange(_size189):
10249 
            _elem194 = Order()
10250 
            _elem194.read(iprot)
10251 
            self.success.append(_elem194)
10252 
          iprot.readListEnd()
10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      else:
10256 
        iprot.skip(ftype)
10257 
      iprot.readFieldEnd()
10258 
    iprot.readStructEnd()
10259 
 
10260 
  def write(self, oprot):
10261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10263 
      return
10264 
    oprot.writeStructBegin('getOrderListForVendor_result')
10265 
    if self.success is not None:
10266 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10267 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10268 
      for iter195 in self.success:
10269 
        iter195.write(oprot)
10270 
      oprot.writeListEnd()
10271 
      oprot.writeFieldEnd()
10272 
    oprot.writeFieldStop()
10273 
    oprot.writeStructEnd()
10274 
 
10275 
  def validate(self):
10276 
    return
10277 
 
10278 
 
10279 
  def __repr__(self):
10280 
    L = ['%s=%r' % (key, value)
10281 
      for key, value in self.__dict__.iteritems()]
10282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10283 
 
10284 
  def __eq__(self, other):
10285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10286 
 
10287 
  def __ne__(self, other):
10288 
    return not (self == other)
10289 
 
3064 chandransh 10290 
class getOrderForCustomer_args:
94 ashish 10291 
  """
10292 
  Attributes:
3064 chandransh 10293 
   - orderId
483 rajveer 10294 
   - customerId
94 ashish 10295 
  """
10296 
 
10297 
  thrift_spec = (
10298 
    None, # 0
3064 chandransh 10299 
    (1, TType.I64, 'orderId', None, None, ), # 1
10300 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10301 
  )
10302 
 
3064 chandransh 10303 
  def __init__(self, orderId=None, customerId=None,):
10304 
    self.orderId = orderId
483 rajveer 10305 
    self.customerId = customerId
94 ashish 10306 
 
10307 
  def read(self, iprot):
10308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10310 
      return
10311 
    iprot.readStructBegin()
10312 
    while True:
10313 
      (fname, ftype, fid) = iprot.readFieldBegin()
10314 
      if ftype == TType.STOP:
10315 
        break
10316 
      if fid == 1:
10317 
        if ftype == TType.I64:
3064 chandransh 10318 
          self.orderId = iprot.readI64();
94 ashish 10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      elif fid == 2:
10322 
        if ftype == TType.I64:
3064 chandransh 10323 
          self.customerId = iprot.readI64();
94 ashish 10324 
        else:
10325 
          iprot.skip(ftype)
10326 
      else:
10327 
        iprot.skip(ftype)
10328 
      iprot.readFieldEnd()
10329 
    iprot.readStructEnd()
10330 
 
10331 
  def write(self, oprot):
10332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10334 
      return
3064 chandransh 10335 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10336 
    if self.orderId is not None:
3064 chandransh 10337 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10338 
      oprot.writeI64(self.orderId)
10339 
      oprot.writeFieldEnd()
3431 rajveer 10340 
    if self.customerId is not None:
3064 chandransh 10341 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10342 
      oprot.writeI64(self.customerId)
94 ashish 10343 
      oprot.writeFieldEnd()
10344 
    oprot.writeFieldStop()
10345 
    oprot.writeStructEnd()
10346 
 
3431 rajveer 10347 
  def validate(self):
10348 
    return
10349 
 
10350 
 
94 ashish 10351 
  def __repr__(self):
10352 
    L = ['%s=%r' % (key, value)
10353 
      for key, value in self.__dict__.iteritems()]
10354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10355 
 
10356 
  def __eq__(self, other):
10357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10358 
 
10359 
  def __ne__(self, other):
10360 
    return not (self == other)
10361 
 
3064 chandransh 10362 
class getOrderForCustomer_result:
94 ashish 10363 
  """
10364 
  Attributes:
10365 
   - success
10366 
   - ex
10367 
  """
10368 
 
10369 
  thrift_spec = (
3064 chandransh 10370 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10372 
  )
10373 
 
10374 
  def __init__(self, success=None, ex=None,):
10375 
    self.success = success
10376 
    self.ex = ex
10377 
 
10378 
  def read(self, iprot):
10379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10381 
      return
10382 
    iprot.readStructBegin()
10383 
    while True:
10384 
      (fname, ftype, fid) = iprot.readFieldBegin()
10385 
      if ftype == TType.STOP:
10386 
        break
10387 
      if fid == 0:
3064 chandransh 10388 
        if ftype == TType.STRUCT:
10389 
          self.success = Order()
10390 
          self.success.read(iprot)
94 ashish 10391 
        else:
10392 
          iprot.skip(ftype)
10393 
      elif fid == 1:
10394 
        if ftype == TType.STRUCT:
10395 
          self.ex = TransactionServiceException()
10396 
          self.ex.read(iprot)
10397 
        else:
10398 
          iprot.skip(ftype)
10399 
      else:
10400 
        iprot.skip(ftype)
10401 
      iprot.readFieldEnd()
10402 
    iprot.readStructEnd()
10403 
 
10404 
  def write(self, oprot):
10405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10407 
      return
3064 chandransh 10408 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10409 
    if self.success is not None:
3064 chandransh 10410 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10411 
      self.success.write(oprot)
94 ashish 10412 
      oprot.writeFieldEnd()
3431 rajveer 10413 
    if self.ex is not None:
94 ashish 10414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10415 
      self.ex.write(oprot)
10416 
      oprot.writeFieldEnd()
10417 
    oprot.writeFieldStop()
10418 
    oprot.writeStructEnd()
10419 
 
3431 rajveer 10420 
  def validate(self):
10421 
    return
10422 
 
10423 
 
94 ashish 10424 
  def __repr__(self):
10425 
    L = ['%s=%r' % (key, value)
10426 
      for key, value in self.__dict__.iteritems()]
10427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10428 
 
10429 
  def __eq__(self, other):
10430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10431 
 
10432 
  def __ne__(self, other):
10433 
    return not (self == other)
10434 
 
3064 chandransh 10435 
class getAlerts_args:
94 ashish 10436 
  """
10437 
  Attributes:
4394 rajveer 10438 
   - type
4444 rajveer 10439 
   - warehouseId
4394 rajveer 10440 
   - status
10441 
   - timestamp
94 ashish 10442 
  """
10443 
 
10444 
  thrift_spec = (
10445 
    None, # 0
4394 rajveer 10446 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10447 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10448 
    (3, TType.I64, 'status', None, None, ), # 3
10449 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10450 
  )
10451 
 
4444 rajveer 10452 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10453 
    self.type = type
4444 rajveer 10454 
    self.warehouseId = warehouseId
4394 rajveer 10455 
    self.status = status
10456 
    self.timestamp = timestamp
94 ashish 10457 
 
10458 
  def read(self, iprot):
10459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10461 
      return
10462 
    iprot.readStructBegin()
10463 
    while True:
10464 
      (fname, ftype, fid) = iprot.readFieldBegin()
10465 
      if ftype == TType.STOP:
10466 
        break
10467 
      if fid == 1:
3064 chandransh 10468 
        if ftype == TType.I64:
4394 rajveer 10469 
          self.type = iprot.readI64();
94 ashish 10470 
        else:
10471 
          iprot.skip(ftype)
3064 chandransh 10472 
      elif fid == 2:
4394 rajveer 10473 
        if ftype == TType.I64:
4444 rajveer 10474 
          self.warehouseId = iprot.readI64();
3064 chandransh 10475 
        else:
10476 
          iprot.skip(ftype)
4394 rajveer 10477 
      elif fid == 3:
10478 
        if ftype == TType.I64:
4444 rajveer 10479 
          self.status = iprot.readI64();
10480 
        else:
10481 
          iprot.skip(ftype)
10482 
      elif fid == 4:
10483 
        if ftype == TType.I64:
4394 rajveer 10484 
          self.timestamp = iprot.readI64();
10485 
        else:
10486 
          iprot.skip(ftype)
94 ashish 10487 
      else:
10488 
        iprot.skip(ftype)
10489 
      iprot.readFieldEnd()
10490 
    iprot.readStructEnd()
10491 
 
10492 
  def write(self, oprot):
10493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10495 
      return
3064 chandransh 10496 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10497 
    if self.type is not None:
10498 
      oprot.writeFieldBegin('type', TType.I64, 1)
10499 
      oprot.writeI64(self.type)
94 ashish 10500 
      oprot.writeFieldEnd()
4444 rajveer 10501 
    if self.warehouseId is not None:
10502 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10503 
      oprot.writeI64(self.warehouseId)
10504 
      oprot.writeFieldEnd()
4394 rajveer 10505 
    if self.status is not None:
4444 rajveer 10506 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10507 
      oprot.writeI64(self.status)
3064 chandransh 10508 
      oprot.writeFieldEnd()
4394 rajveer 10509 
    if self.timestamp is not None:
4444 rajveer 10510 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10511 
      oprot.writeI64(self.timestamp)
10512 
      oprot.writeFieldEnd()
94 ashish 10513 
    oprot.writeFieldStop()
10514 
    oprot.writeStructEnd()
10515 
 
3431 rajveer 10516 
  def validate(self):
10517 
    return
10518 
 
10519 
 
94 ashish 10520 
  def __repr__(self):
10521 
    L = ['%s=%r' % (key, value)
10522 
      for key, value in self.__dict__.iteritems()]
10523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10524 
 
10525 
  def __eq__(self, other):
10526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10527 
 
10528 
  def __ne__(self, other):
10529 
    return not (self == other)
10530 
 
3064 chandransh 10531 
class getAlerts_result:
94 ashish 10532 
  """
10533 
  Attributes:
10534 
   - success
10535 
  """
10536 
 
10537 
  thrift_spec = (
3064 chandransh 10538 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10539 
  )
10540 
 
3064 chandransh 10541 
  def __init__(self, success=None,):
94 ashish 10542 
    self.success = success
10543 
 
10544 
  def read(self, iprot):
10545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10547 
      return
10548 
    iprot.readStructBegin()
10549 
    while True:
10550 
      (fname, ftype, fid) = iprot.readFieldBegin()
10551 
      if ftype == TType.STOP:
10552 
        break
10553 
      if fid == 0:
3064 chandransh 10554 
        if ftype == TType.LIST:
10555 
          self.success = []
5386 phani.kuma 10556 
          (_etype199, _size196) = iprot.readListBegin()
10557 
          for _i200 in xrange(_size196):
10558 
            _elem201 = Alert()
10559 
            _elem201.read(iprot)
10560 
            self.success.append(_elem201)
3064 chandransh 10561 
          iprot.readListEnd()
94 ashish 10562 
        else:
10563 
          iprot.skip(ftype)
10564 
      else:
10565 
        iprot.skip(ftype)
10566 
      iprot.readFieldEnd()
10567 
    iprot.readStructEnd()
10568 
 
10569 
  def write(self, oprot):
10570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10572 
      return
3064 chandransh 10573 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10574 
    if self.success is not None:
3064 chandransh 10575 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10576 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10577 
      for iter202 in self.success:
10578 
        iter202.write(oprot)
3064 chandransh 10579 
      oprot.writeListEnd()
94 ashish 10580 
      oprot.writeFieldEnd()
10581 
    oprot.writeFieldStop()
10582 
    oprot.writeStructEnd()
10583 
 
3431 rajveer 10584 
  def validate(self):
10585 
    return
10586 
 
10587 
 
94 ashish 10588 
  def __repr__(self):
10589 
    L = ['%s=%r' % (key, value)
10590 
      for key, value in self.__dict__.iteritems()]
10591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10592 
 
10593 
  def __eq__(self, other):
10594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10595 
 
10596 
  def __ne__(self, other):
10597 
    return not (self == other)
10598 
 
4394 rajveer 10599 
class addAlert_args:
94 ashish 10600 
  """
10601 
  Attributes:
3064 chandransh 10602 
   - type
4444 rajveer 10603 
   - warehouseId
4394 rajveer 10604 
   - description
94 ashish 10605 
  """
10606 
 
10607 
  thrift_spec = (
10608 
    None, # 0
4394 rajveer 10609 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10610 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10611 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10612 
  )
10613 
 
4444 rajveer 10614 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10615 
    self.type = type
4444 rajveer 10616 
    self.warehouseId = warehouseId
4394 rajveer 10617 
    self.description = description
94 ashish 10618 
 
10619 
  def read(self, iprot):
10620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10622 
      return
10623 
    iprot.readStructBegin()
10624 
    while True:
10625 
      (fname, ftype, fid) = iprot.readFieldBegin()
10626 
      if ftype == TType.STOP:
10627 
        break
10628 
      if fid == 1:
10629 
        if ftype == TType.I64:
4394 rajveer 10630 
          self.type = iprot.readI64();
94 ashish 10631 
        else:
10632 
          iprot.skip(ftype)
3064 chandransh 10633 
      elif fid == 2:
4444 rajveer 10634 
        if ftype == TType.I64:
10635 
          self.warehouseId = iprot.readI64();
10636 
        else:
10637 
          iprot.skip(ftype)
10638 
      elif fid == 3:
3064 chandransh 10639 
        if ftype == TType.STRING:
4394 rajveer 10640 
          self.description = iprot.readString();
3064 chandransh 10641 
        else:
10642 
          iprot.skip(ftype)
94 ashish 10643 
      else:
10644 
        iprot.skip(ftype)
10645 
      iprot.readFieldEnd()
10646 
    iprot.readStructEnd()
10647 
 
10648 
  def write(self, oprot):
10649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10651 
      return
4394 rajveer 10652 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10653 
    if self.type is not None:
4394 rajveer 10654 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10655 
      oprot.writeI64(self.type)
10656 
      oprot.writeFieldEnd()
4444 rajveer 10657 
    if self.warehouseId is not None:
10658 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10659 
      oprot.writeI64(self.warehouseId)
10660 
      oprot.writeFieldEnd()
4394 rajveer 10661 
    if self.description is not None:
4444 rajveer 10662 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10663 
      oprot.writeString(self.description)
3064 chandransh 10664 
      oprot.writeFieldEnd()
94 ashish 10665 
    oprot.writeFieldStop()
10666 
    oprot.writeStructEnd()
10667 
 
3431 rajveer 10668 
  def validate(self):
10669 
    return
10670 
 
10671 
 
94 ashish 10672 
  def __repr__(self):
10673 
    L = ['%s=%r' % (key, value)
10674 
      for key, value in self.__dict__.iteritems()]
10675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10676 
 
10677 
  def __eq__(self, other):
10678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10679 
 
10680 
  def __ne__(self, other):
10681 
    return not (self == other)
10682 
 
4394 rajveer 10683 
class addAlert_result:
3064 chandransh 10684 
 
10685 
  thrift_spec = (
10686 
  )
10687 
 
10688 
  def read(self, iprot):
10689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10691 
      return
10692 
    iprot.readStructBegin()
10693 
    while True:
10694 
      (fname, ftype, fid) = iprot.readFieldBegin()
10695 
      if ftype == TType.STOP:
10696 
        break
10697 
      else:
10698 
        iprot.skip(ftype)
10699 
      iprot.readFieldEnd()
10700 
    iprot.readStructEnd()
10701 
 
10702 
  def write(self, oprot):
10703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10705 
      return
4394 rajveer 10706 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10707 
    oprot.writeFieldStop()
10708 
    oprot.writeStructEnd()
10709 
 
3431 rajveer 10710 
  def validate(self):
10711 
    return
10712 
 
10713 
 
3064 chandransh 10714 
  def __repr__(self):
10715 
    L = ['%s=%r' % (key, value)
10716 
      for key, value in self.__dict__.iteritems()]
10717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10718 
 
10719 
  def __eq__(self, other):
10720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10721 
 
10722 
  def __ne__(self, other):
10723 
    return not (self == other)
10724 
 
4444 rajveer 10725 
class markAlertsAsSeen_args:
10726 
  """
10727 
  Attributes:
10728 
   - warehouseId
10729 
  """
10730 
 
10731 
  thrift_spec = (
10732 
    None, # 0
10733 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10734 
  )
10735 
 
10736 
  def __init__(self, warehouseId=None,):
10737 
    self.warehouseId = warehouseId
10738 
 
10739 
  def read(self, iprot):
10740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10742 
      return
10743 
    iprot.readStructBegin()
10744 
    while True:
10745 
      (fname, ftype, fid) = iprot.readFieldBegin()
10746 
      if ftype == TType.STOP:
10747 
        break
10748 
      if fid == 1:
10749 
        if ftype == TType.I64:
10750 
          self.warehouseId = iprot.readI64();
10751 
        else:
10752 
          iprot.skip(ftype)
10753 
      else:
10754 
        iprot.skip(ftype)
10755 
      iprot.readFieldEnd()
10756 
    iprot.readStructEnd()
10757 
 
10758 
  def write(self, oprot):
10759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10761 
      return
10762 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10763 
    if self.warehouseId is not None:
10764 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10765 
      oprot.writeI64(self.warehouseId)
10766 
      oprot.writeFieldEnd()
10767 
    oprot.writeFieldStop()
10768 
    oprot.writeStructEnd()
10769 
 
10770 
  def validate(self):
10771 
    return
10772 
 
10773 
 
10774 
  def __repr__(self):
10775 
    L = ['%s=%r' % (key, value)
10776 
      for key, value in self.__dict__.iteritems()]
10777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10778 
 
10779 
  def __eq__(self, other):
10780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10781 
 
10782 
  def __ne__(self, other):
10783 
    return not (self == other)
10784 
 
10785 
class markAlertsAsSeen_result:
10786 
 
10787 
  thrift_spec = (
10788 
  )
10789 
 
10790 
  def read(self, iprot):
10791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10793 
      return
10794 
    iprot.readStructBegin()
10795 
    while True:
10796 
      (fname, ftype, fid) = iprot.readFieldBegin()
10797 
      if ftype == TType.STOP:
10798 
        break
10799 
      else:
10800 
        iprot.skip(ftype)
10801 
      iprot.readFieldEnd()
10802 
    iprot.readStructEnd()
10803 
 
10804 
  def write(self, oprot):
10805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10807 
      return
10808 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10809 
    oprot.writeFieldStop()
10810 
    oprot.writeStructEnd()
10811 
 
10812 
  def validate(self):
10813 
    return
10814 
 
10815 
 
10816 
  def __repr__(self):
10817 
    L = ['%s=%r' % (key, value)
10818 
      for key, value in self.__dict__.iteritems()]
10819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10820 
 
10821 
  def __eq__(self, other):
10822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10823 
 
10824 
  def __ne__(self, other):
10825 
    return not (self == other)
10826 
 
3064 chandransh 10827 
class getValidOrderCount_args:
10828 
 
10829 
  thrift_spec = (
10830 
  )
10831 
 
10832 
  def read(self, iprot):
10833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10835 
      return
10836 
    iprot.readStructBegin()
10837 
    while True:
10838 
      (fname, ftype, fid) = iprot.readFieldBegin()
10839 
      if ftype == TType.STOP:
10840 
        break
10841 
      else:
10842 
        iprot.skip(ftype)
10843 
      iprot.readFieldEnd()
10844 
    iprot.readStructEnd()
10845 
 
10846 
  def write(self, oprot):
10847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10849 
      return
10850 
    oprot.writeStructBegin('getValidOrderCount_args')
10851 
    oprot.writeFieldStop()
10852 
    oprot.writeStructEnd()
10853 
 
3431 rajveer 10854 
  def validate(self):
10855 
    return
10856 
 
10857 
 
3064 chandransh 10858 
  def __repr__(self):
10859 
    L = ['%s=%r' % (key, value)
10860 
      for key, value in self.__dict__.iteritems()]
10861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10862 
 
10863 
  def __eq__(self, other):
10864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10865 
 
10866 
  def __ne__(self, other):
10867 
    return not (self == other)
10868 
 
10869 
class getValidOrderCount_result:
94 ashish 10870 
  """
10871 
  Attributes:
10872 
   - success
10873 
  """
10874 
 
10875 
  thrift_spec = (
3064 chandransh 10876 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10877 
  )
10878 
 
3064 chandransh 10879 
  def __init__(self, success=None,):
94 ashish 10880 
    self.success = success
10881 
 
10882 
  def read(self, iprot):
10883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10885 
      return
10886 
    iprot.readStructBegin()
10887 
    while True:
10888 
      (fname, ftype, fid) = iprot.readFieldBegin()
10889 
      if ftype == TType.STOP:
10890 
        break
10891 
      if fid == 0:
3064 chandransh 10892 
        if ftype == TType.I64:
10893 
          self.success = iprot.readI64();
94 ashish 10894 
        else:
10895 
          iprot.skip(ftype)
10896 
      else:
10897 
        iprot.skip(ftype)
10898 
      iprot.readFieldEnd()
10899 
    iprot.readStructEnd()
10900 
 
10901 
  def write(self, oprot):
10902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10904 
      return
3064 chandransh 10905 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10906 
    if self.success is not None:
3064 chandransh 10907 
      oprot.writeFieldBegin('success', TType.I64, 0)
10908 
      oprot.writeI64(self.success)
94 ashish 10909 
      oprot.writeFieldEnd()
10910 
    oprot.writeFieldStop()
10911 
    oprot.writeStructEnd()
10912 
 
3431 rajveer 10913 
  def validate(self):
10914 
    return
10915 
 
10916 
 
94 ashish 10917 
  def __repr__(self):
10918 
    L = ['%s=%r' % (key, value)
10919 
      for key, value in self.__dict__.iteritems()]
10920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10921 
 
10922 
  def __eq__(self, other):
10923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10924 
 
10925 
  def __ne__(self, other):
10926 
    return not (self == other)
10927 
 
3064 chandransh 10928 
class getNoOfCustomersWithSuccessfulTransaction_args:
10929 
 
10930 
  thrift_spec = (
10931 
  )
10932 
 
10933 
  def read(self, iprot):
10934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10936 
      return
10937 
    iprot.readStructBegin()
10938 
    while True:
10939 
      (fname, ftype, fid) = iprot.readFieldBegin()
10940 
      if ftype == TType.STOP:
10941 
        break
10942 
      else:
10943 
        iprot.skip(ftype)
10944 
      iprot.readFieldEnd()
10945 
    iprot.readStructEnd()
10946 
 
10947 
  def write(self, oprot):
10948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10950 
      return
10951 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10952 
    oprot.writeFieldStop()
10953 
    oprot.writeStructEnd()
10954 
 
3431 rajveer 10955 
  def validate(self):
10956 
    return
10957 
 
10958 
 
3064 chandransh 10959 
  def __repr__(self):
10960 
    L = ['%s=%r' % (key, value)
10961 
      for key, value in self.__dict__.iteritems()]
10962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10963 
 
10964 
  def __eq__(self, other):
10965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10966 
 
10967 
  def __ne__(self, other):
10968 
    return not (self == other)
10969 
 
10970 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10971 
  """
10972 
  Attributes:
3064 chandransh 10973 
   - success
94 ashish 10974 
  """
10975 
 
10976 
  thrift_spec = (
3064 chandransh 10977 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10978 
  )
10979 
 
3064 chandransh 10980 
  def __init__(self, success=None,):
10981 
    self.success = success
94 ashish 10982 
 
10983 
  def read(self, iprot):
10984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10986 
      return
10987 
    iprot.readStructBegin()
10988 
    while True:
10989 
      (fname, ftype, fid) = iprot.readFieldBegin()
10990 
      if ftype == TType.STOP:
10991 
        break
3064 chandransh 10992 
      if fid == 0:
94 ashish 10993 
        if ftype == TType.I64:
3064 chandransh 10994 
          self.success = iprot.readI64();
94 ashish 10995 
        else:
10996 
          iprot.skip(ftype)
10997 
      else:
10998 
        iprot.skip(ftype)
10999 
      iprot.readFieldEnd()
11000 
    iprot.readStructEnd()
11001 
 
11002 
  def write(self, oprot):
11003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11005 
      return
3064 chandransh 11006 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11007 
    if self.success is not None:
3064 chandransh 11008 
      oprot.writeFieldBegin('success', TType.I64, 0)
11009 
      oprot.writeI64(self.success)
94 ashish 11010 
      oprot.writeFieldEnd()
11011 
    oprot.writeFieldStop()
11012 
    oprot.writeStructEnd()
11013 
 
3431 rajveer 11014 
  def validate(self):
11015 
    return
11016 
 
11017 
 
94 ashish 11018 
  def __repr__(self):
11019 
    L = ['%s=%r' % (key, value)
11020 
      for key, value in self.__dict__.iteritems()]
11021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11022 
 
11023 
  def __eq__(self, other):
11024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11025 
 
11026 
  def __ne__(self, other):
11027 
    return not (self == other)
11028 
 
3064 chandransh 11029 
class getValidOrdersAmountRange_args:
11030 
 
11031 
  thrift_spec = (
11032 
  )
11033 
 
11034 
  def read(self, iprot):
11035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11037 
      return
11038 
    iprot.readStructBegin()
11039 
    while True:
11040 
      (fname, ftype, fid) = iprot.readFieldBegin()
11041 
      if ftype == TType.STOP:
11042 
        break
11043 
      else:
11044 
        iprot.skip(ftype)
11045 
      iprot.readFieldEnd()
11046 
    iprot.readStructEnd()
11047 
 
11048 
  def write(self, oprot):
11049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11051 
      return
11052 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11053 
    oprot.writeFieldStop()
11054 
    oprot.writeStructEnd()
11055 
 
3431 rajveer 11056 
  def validate(self):
11057 
    return
11058 
 
11059 
 
3064 chandransh 11060 
  def __repr__(self):
11061 
    L = ['%s=%r' % (key, value)
11062 
      for key, value in self.__dict__.iteritems()]
11063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11064 
 
11065 
  def __eq__(self, other):
11066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11067 
 
11068 
  def __ne__(self, other):
11069 
    return not (self == other)
11070 
 
11071 
class getValidOrdersAmountRange_result:
94 ashish 11072 
  """
11073 
  Attributes:
11074 
   - success
11075 
  """
11076 
 
11077 
  thrift_spec = (
3064 chandransh 11078 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11079 
  )
11080 
 
3064 chandransh 11081 
  def __init__(self, success=None,):
94 ashish 11082 
    self.success = success
11083 
 
11084 
  def read(self, iprot):
11085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11087 
      return
11088 
    iprot.readStructBegin()
11089 
    while True:
11090 
      (fname, ftype, fid) = iprot.readFieldBegin()
11091 
      if ftype == TType.STOP:
11092 
        break
11093 
      if fid == 0:
483 rajveer 11094 
        if ftype == TType.LIST:
11095 
          self.success = []
5386 phani.kuma 11096 
          (_etype206, _size203) = iprot.readListBegin()
11097 
          for _i207 in xrange(_size203):
11098 
            _elem208 = iprot.readDouble();
11099 
            self.success.append(_elem208)
483 rajveer 11100 
          iprot.readListEnd()
94 ashish 11101 
        else:
11102 
          iprot.skip(ftype)
11103 
      else:
11104 
        iprot.skip(ftype)
11105 
      iprot.readFieldEnd()
11106 
    iprot.readStructEnd()
11107 
 
11108 
  def write(self, oprot):
11109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11111 
      return
3064 chandransh 11112 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11113 
    if self.success is not None:
483 rajveer 11114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11115 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11116 
      for iter209 in self.success:
11117 
        oprot.writeDouble(iter209)
483 rajveer 11118 
      oprot.writeListEnd()
94 ashish 11119 
      oprot.writeFieldEnd()
11120 
    oprot.writeFieldStop()
11121 
    oprot.writeStructEnd()
11122 
 
3431 rajveer 11123 
  def validate(self):
11124 
    return
11125 
 
11126 
 
94 ashish 11127 
  def __repr__(self):
11128 
    L = ['%s=%r' % (key, value)
11129 
      for key, value in self.__dict__.iteritems()]
11130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11131 
 
11132 
  def __eq__(self, other):
11133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11134 
 
11135 
  def __ne__(self, other):
11136 
    return not (self == other)
11137 
 
3064 chandransh 11138 
class getValidOrders_args:
1528 ankur.sing 11139 
  """
11140 
  Attributes:
3064 chandransh 11141 
   - limit
1528 ankur.sing 11142 
  """
11143 
 
11144 
  thrift_spec = (
11145 
    None, # 0
3064 chandransh 11146 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11147 
  )
11148 
 
3064 chandransh 11149 
  def __init__(self, limit=None,):
11150 
    self.limit = limit
1528 ankur.sing 11151 
 
11152 
  def read(self, iprot):
11153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11155 
      return
11156 
    iprot.readStructBegin()
11157 
    while True:
11158 
      (fname, ftype, fid) = iprot.readFieldBegin()
11159 
      if ftype == TType.STOP:
11160 
        break
11161 
      if fid == 1:
11162 
        if ftype == TType.I64:
3064 chandransh 11163 
          self.limit = iprot.readI64();
1528 ankur.sing 11164 
        else:
11165 
          iprot.skip(ftype)
11166 
      else:
11167 
        iprot.skip(ftype)
11168 
      iprot.readFieldEnd()
11169 
    iprot.readStructEnd()
11170 
 
11171 
  def write(self, oprot):
11172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11174 
      return
3064 chandransh 11175 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11176 
    if self.limit is not None:
3064 chandransh 11177 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11178 
      oprot.writeI64(self.limit)
1528 ankur.sing 11179 
      oprot.writeFieldEnd()
11180 
    oprot.writeFieldStop()
11181 
    oprot.writeStructEnd()
11182 
 
3431 rajveer 11183 
  def validate(self):
11184 
    return
11185 
 
11186 
 
1528 ankur.sing 11187 
  def __repr__(self):
11188 
    L = ['%s=%r' % (key, value)
11189 
      for key, value in self.__dict__.iteritems()]
11190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11191 
 
11192 
  def __eq__(self, other):
11193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11194 
 
11195 
  def __ne__(self, other):
11196 
    return not (self == other)
11197 
 
3064 chandransh 11198 
class getValidOrders_result:
1528 ankur.sing 11199 
  """
11200 
  Attributes:
11201 
   - success
11202 
  """
11203 
 
11204 
  thrift_spec = (
3064 chandransh 11205 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11206 
  )
11207 
 
3064 chandransh 11208 
  def __init__(self, success=None,):
1528 ankur.sing 11209 
    self.success = success
11210 
 
11211 
  def read(self, iprot):
11212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11214 
      return
11215 
    iprot.readStructBegin()
11216 
    while True:
11217 
      (fname, ftype, fid) = iprot.readFieldBegin()
11218 
      if ftype == TType.STOP:
11219 
        break
11220 
      if fid == 0:
3064 chandransh 11221 
        if ftype == TType.LIST:
11222 
          self.success = []
5386 phani.kuma 11223 
          (_etype213, _size210) = iprot.readListBegin()
11224 
          for _i214 in xrange(_size210):
11225 
            _elem215 = Order()
11226 
            _elem215.read(iprot)
11227 
            self.success.append(_elem215)
3064 chandransh 11228 
          iprot.readListEnd()
1528 ankur.sing 11229 
        else:
11230 
          iprot.skip(ftype)
11231 
      else:
11232 
        iprot.skip(ftype)
11233 
      iprot.readFieldEnd()
11234 
    iprot.readStructEnd()
11235 
 
11236 
  def write(self, oprot):
11237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11239 
      return
3064 chandransh 11240 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11241 
    if self.success is not None:
3064 chandransh 11242 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11243 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11244 
      for iter216 in self.success:
11245 
        iter216.write(oprot)
3064 chandransh 11246 
      oprot.writeListEnd()
1528 ankur.sing 11247 
      oprot.writeFieldEnd()
11248 
    oprot.writeFieldStop()
11249 
    oprot.writeStructEnd()
11250 
 
3431 rajveer 11251 
  def validate(self):
11252 
    return
11253 
 
11254 
 
1528 ankur.sing 11255 
  def __repr__(self):
11256 
    L = ['%s=%r' % (key, value)
11257 
      for key, value in self.__dict__.iteritems()]
11258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11259 
 
11260 
  def __eq__(self, other):
11261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11262 
 
11263 
  def __ne__(self, other):
11264 
    return not (self == other)
11265 
 
1220 chandransh 11266 
class batchOrders_args:
11267 
  """
11268 
  Attributes:
11269 
   - warehouseId
11270 
  """
11271 
 
11272 
  thrift_spec = (
11273 
    None, # 0
11274 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11275 
  )
11276 
 
11277 
  def __init__(self, warehouseId=None,):
11278 
    self.warehouseId = warehouseId
11279 
 
11280 
  def read(self, iprot):
11281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11283 
      return
11284 
    iprot.readStructBegin()
11285 
    while True:
11286 
      (fname, ftype, fid) = iprot.readFieldBegin()
11287 
      if ftype == TType.STOP:
11288 
        break
11289 
      if fid == 1:
11290 
        if ftype == TType.I64:
11291 
          self.warehouseId = iprot.readI64();
11292 
        else:
11293 
          iprot.skip(ftype)
11294 
      else:
11295 
        iprot.skip(ftype)
11296 
      iprot.readFieldEnd()
11297 
    iprot.readStructEnd()
11298 
 
11299 
  def write(self, oprot):
11300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11302 
      return
11303 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11304 
    if self.warehouseId is not None:
1220 chandransh 11305 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11306 
      oprot.writeI64(self.warehouseId)
11307 
      oprot.writeFieldEnd()
11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
3431 rajveer 11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
1220 chandransh 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 
 
11326 
class batchOrders_result:
11327 
  """
11328 
  Attributes:
11329 
   - success
11330 
   - ex
11331 
  """
11332 
 
11333 
  thrift_spec = (
11334 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11336 
  )
11337 
 
11338 
  def __init__(self, success=None, ex=None,):
11339 
    self.success = success
11340 
    self.ex = ex
11341 
 
11342 
  def read(self, iprot):
11343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11345 
      return
11346 
    iprot.readStructBegin()
11347 
    while True:
11348 
      (fname, ftype, fid) = iprot.readFieldBegin()
11349 
      if ftype == TType.STOP:
11350 
        break
11351 
      if fid == 0:
11352 
        if ftype == TType.LIST:
11353 
          self.success = []
5386 phani.kuma 11354 
          (_etype220, _size217) = iprot.readListBegin()
11355 
          for _i221 in xrange(_size217):
11356 
            _elem222 = Order()
11357 
            _elem222.read(iprot)
11358 
            self.success.append(_elem222)
1220 chandransh 11359 
          iprot.readListEnd()
11360 
        else:
11361 
          iprot.skip(ftype)
11362 
      elif fid == 1:
11363 
        if ftype == TType.STRUCT:
11364 
          self.ex = TransactionServiceException()
11365 
          self.ex.read(iprot)
11366 
        else:
11367 
          iprot.skip(ftype)
11368 
      else:
11369 
        iprot.skip(ftype)
11370 
      iprot.readFieldEnd()
11371 
    iprot.readStructEnd()
11372 
 
11373 
  def write(self, oprot):
11374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11376 
      return
11377 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11378 
    if self.success is not None:
1220 chandransh 11379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11380 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11381 
      for iter223 in self.success:
11382 
        iter223.write(oprot)
1220 chandransh 11383 
      oprot.writeListEnd()
11384 
      oprot.writeFieldEnd()
3431 rajveer 11385 
    if self.ex is not None:
1220 chandransh 11386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11387 
      self.ex.write(oprot)
11388 
      oprot.writeFieldEnd()
11389 
    oprot.writeFieldStop()
11390 
    oprot.writeStructEnd()
11391 
 
3431 rajveer 11392 
  def validate(self):
11393 
    return
11394 
 
11395 
 
1220 chandransh 11396 
  def __repr__(self):
11397 
    L = ['%s=%r' % (key, value)
11398 
      for key, value in self.__dict__.iteritems()]
11399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11400 
 
11401 
  def __eq__(self, other):
11402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11403 
 
11404 
  def __ne__(self, other):
11405 
    return not (self == other)
11406 
 
1208 chandransh 11407 
class markOrderAsOutOfStock_args:
11408 
  """
11409 
  Attributes:
11410 
   - orderId
11411 
  """
11412 
 
11413 
  thrift_spec = (
11414 
    None, # 0
11415 
    (1, TType.I64, 'orderId', None, None, ), # 1
11416 
  )
11417 
 
11418 
  def __init__(self, orderId=None,):
11419 
    self.orderId = orderId
11420 
 
11421 
  def read(self, iprot):
11422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11424 
      return
11425 
    iprot.readStructBegin()
11426 
    while True:
11427 
      (fname, ftype, fid) = iprot.readFieldBegin()
11428 
      if ftype == TType.STOP:
11429 
        break
11430 
      if fid == 1:
11431 
        if ftype == TType.I64:
11432 
          self.orderId = iprot.readI64();
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      else:
11436 
        iprot.skip(ftype)
11437 
      iprot.readFieldEnd()
11438 
    iprot.readStructEnd()
11439 
 
11440 
  def write(self, oprot):
11441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11443 
      return
11444 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11445 
    if self.orderId is not None:
1208 chandransh 11446 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11447 
      oprot.writeI64(self.orderId)
11448 
      oprot.writeFieldEnd()
11449 
    oprot.writeFieldStop()
11450 
    oprot.writeStructEnd()
11451 
 
3431 rajveer 11452 
  def validate(self):
11453 
    return
11454 
 
11455 
 
1208 chandransh 11456 
  def __repr__(self):
11457 
    L = ['%s=%r' % (key, value)
11458 
      for key, value in self.__dict__.iteritems()]
11459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11460 
 
11461 
  def __eq__(self, other):
11462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11463 
 
11464 
  def __ne__(self, other):
11465 
    return not (self == other)
11466 
 
11467 
class markOrderAsOutOfStock_result:
11468 
  """
11469 
  Attributes:
11470 
   - success
11471 
   - ex
11472 
  """
11473 
 
11474 
  thrift_spec = (
11475 
    (0, TType.BOOL, 'success', None, None, ), # 0
11476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11477 
  )
11478 
 
11479 
  def __init__(self, success=None, ex=None,):
11480 
    self.success = success
11481 
    self.ex = ex
11482 
 
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
11492 
      if fid == 0:
11493 
        if ftype == TType.BOOL:
11494 
          self.success = iprot.readBool();
11495 
        else:
11496 
          iprot.skip(ftype)
11497 
      elif fid == 1:
11498 
        if ftype == TType.STRUCT:
11499 
          self.ex = TransactionServiceException()
11500 
          self.ex.read(iprot)
11501 
        else:
11502 
          iprot.skip(ftype)
11503 
      else:
11504 
        iprot.skip(ftype)
11505 
      iprot.readFieldEnd()
11506 
    iprot.readStructEnd()
11507 
 
11508 
  def write(self, oprot):
11509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11511 
      return
11512 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11513 
    if self.success is not None:
1208 chandransh 11514 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11515 
      oprot.writeBool(self.success)
11516 
      oprot.writeFieldEnd()
3431 rajveer 11517 
    if self.ex is not None:
1208 chandransh 11518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11519 
      self.ex.write(oprot)
11520 
      oprot.writeFieldEnd()
11521 
    oprot.writeFieldStop()
11522 
    oprot.writeStructEnd()
11523 
 
3431 rajveer 11524 
  def validate(self):
11525 
    return
11526 
 
11527 
 
1208 chandransh 11528 
  def __repr__(self):
11529 
    L = ['%s=%r' % (key, value)
11530 
      for key, value in self.__dict__.iteritems()]
11531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11532 
 
11533 
  def __eq__(self, other):
11534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11535 
 
11536 
  def __ne__(self, other):
11537 
    return not (self == other)
11538 
 
3064 chandransh 11539 
class verifyOrder_args:
759 chandransh 11540 
  """
11541 
  Attributes:
3064 chandransh 11542 
   - orderId
759 chandransh 11543 
  """
11544 
 
11545 
  thrift_spec = (
11546 
    None, # 0
3064 chandransh 11547 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11548 
  )
11549 
 
3064 chandransh 11550 
  def __init__(self, orderId=None,):
11551 
    self.orderId = orderId
759 chandransh 11552 
 
11553 
  def read(self, iprot):
11554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11556 
      return
11557 
    iprot.readStructBegin()
11558 
    while True:
11559 
      (fname, ftype, fid) = iprot.readFieldBegin()
11560 
      if ftype == TType.STOP:
11561 
        break
11562 
      if fid == 1:
11563 
        if ftype == TType.I64:
3064 chandransh 11564 
          self.orderId = iprot.readI64();
759 chandransh 11565 
        else:
11566 
          iprot.skip(ftype)
11567 
      else:
11568 
        iprot.skip(ftype)
11569 
      iprot.readFieldEnd()
11570 
    iprot.readStructEnd()
11571 
 
11572 
  def write(self, oprot):
11573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11575 
      return
3064 chandransh 11576 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11577 
    if self.orderId is not None:
3064 chandransh 11578 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11579 
      oprot.writeI64(self.orderId)
759 chandransh 11580 
      oprot.writeFieldEnd()
11581 
    oprot.writeFieldStop()
11582 
    oprot.writeStructEnd()
11583 
 
3431 rajveer 11584 
  def validate(self):
11585 
    return
11586 
 
11587 
 
759 chandransh 11588 
  def __repr__(self):
11589 
    L = ['%s=%r' % (key, value)
11590 
      for key, value in self.__dict__.iteritems()]
11591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11592 
 
11593 
  def __eq__(self, other):
11594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11595 
 
11596 
  def __ne__(self, other):
11597 
    return not (self == other)
11598 
 
3064 chandransh 11599 
class verifyOrder_result:
759 chandransh 11600 
  """
11601 
  Attributes:
11602 
   - success
11603 
   - ex
11604 
  """
11605 
 
11606 
  thrift_spec = (
11607 
    (0, TType.BOOL, 'success', None, None, ), # 0
11608 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11609 
  )
11610 
 
11611 
  def __init__(self, success=None, ex=None,):
11612 
    self.success = success
11613 
    self.ex = ex
11614 
 
11615 
  def read(self, iprot):
11616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11618 
      return
11619 
    iprot.readStructBegin()
11620 
    while True:
11621 
      (fname, ftype, fid) = iprot.readFieldBegin()
11622 
      if ftype == TType.STOP:
11623 
        break
11624 
      if fid == 0:
11625 
        if ftype == TType.BOOL:
11626 
          self.success = iprot.readBool();
11627 
        else:
11628 
          iprot.skip(ftype)
11629 
      elif fid == 1:
11630 
        if ftype == TType.STRUCT:
11631 
          self.ex = TransactionServiceException()
11632 
          self.ex.read(iprot)
11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      else:
11636 
        iprot.skip(ftype)
11637 
      iprot.readFieldEnd()
11638 
    iprot.readStructEnd()
11639 
 
11640 
  def write(self, oprot):
11641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11643 
      return
3064 chandransh 11644 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11645 
    if self.success is not None:
759 chandransh 11646 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11647 
      oprot.writeBool(self.success)
11648 
      oprot.writeFieldEnd()
3431 rajveer 11649 
    if self.ex is not None:
759 chandransh 11650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11651 
      self.ex.write(oprot)
11652 
      oprot.writeFieldEnd()
11653 
    oprot.writeFieldStop()
11654 
    oprot.writeStructEnd()
11655 
 
3431 rajveer 11656 
  def validate(self):
11657 
    return
11658 
 
11659 
 
759 chandransh 11660 
  def __repr__(self):
11661 
    L = ['%s=%r' % (key, value)
11662 
      for key, value in self.__dict__.iteritems()]
11663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11664 
 
11665 
  def __eq__(self, other):
11666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11667 
 
11668 
  def __ne__(self, other):
11669 
    return not (self == other)
11670 
 
3064 chandransh 11671 
class acceptOrder_args:
1113 chandransh 11672 
  """
11673 
  Attributes:
3064 chandransh 11674 
   - orderId
1113 chandransh 11675 
  """
11676 
 
11677 
  thrift_spec = (
11678 
    None, # 0
3064 chandransh 11679 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11680 
  )
11681 
 
3064 chandransh 11682 
  def __init__(self, orderId=None,):
11683 
    self.orderId = orderId
1113 chandransh 11684 
 
11685 
  def read(self, iprot):
11686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11688 
      return
11689 
    iprot.readStructBegin()
11690 
    while True:
11691 
      (fname, ftype, fid) = iprot.readFieldBegin()
11692 
      if ftype == TType.STOP:
11693 
        break
11694 
      if fid == 1:
11695 
        if ftype == TType.I64:
3064 chandransh 11696 
          self.orderId = iprot.readI64();
1113 chandransh 11697 
        else:
11698 
          iprot.skip(ftype)
11699 
      else:
11700 
        iprot.skip(ftype)
11701 
      iprot.readFieldEnd()
11702 
    iprot.readStructEnd()
11703 
 
11704 
  def write(self, oprot):
11705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11707 
      return
3064 chandransh 11708 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11709 
    if self.orderId is not None:
3064 chandransh 11710 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11711 
      oprot.writeI64(self.orderId)
1113 chandransh 11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
3431 rajveer 11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
1113 chandransh 11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
3064 chandransh 11731 
class acceptOrder_result:
1113 chandransh 11732 
  """
11733 
  Attributes:
11734 
   - success
11735 
   - ex
11736 
  """
11737 
 
11738 
  thrift_spec = (
3064 chandransh 11739 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11741 
  )
11742 
 
11743 
  def __init__(self, success=None, ex=None,):
11744 
    self.success = success
11745 
    self.ex = ex
11746 
 
11747 
  def read(self, iprot):
11748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11750 
      return
11751 
    iprot.readStructBegin()
11752 
    while True:
11753 
      (fname, ftype, fid) = iprot.readFieldBegin()
11754 
      if ftype == TType.STOP:
11755 
        break
11756 
      if fid == 0:
3064 chandransh 11757 
        if ftype == TType.BOOL:
11758 
          self.success = iprot.readBool();
1113 chandransh 11759 
        else:
11760 
          iprot.skip(ftype)
11761 
      elif fid == 1:
11762 
        if ftype == TType.STRUCT:
11763 
          self.ex = TransactionServiceException()
11764 
          self.ex.read(iprot)
11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      else:
11768 
        iprot.skip(ftype)
11769 
      iprot.readFieldEnd()
11770 
    iprot.readStructEnd()
11771 
 
11772 
  def write(self, oprot):
11773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11775 
      return
3064 chandransh 11776 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11777 
    if self.success is not None:
3064 chandransh 11778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11779 
      oprot.writeBool(self.success)
1113 chandransh 11780 
      oprot.writeFieldEnd()
3431 rajveer 11781 
    if self.ex is not None:
1113 chandransh 11782 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11783 
      self.ex.write(oprot)
11784 
      oprot.writeFieldEnd()
11785 
    oprot.writeFieldStop()
11786 
    oprot.writeStructEnd()
11787 
 
3431 rajveer 11788 
  def validate(self):
11789 
    return
11790 
 
11791 
 
1113 chandransh 11792 
  def __repr__(self):
11793 
    L = ['%s=%r' % (key, value)
11794 
      for key, value in self.__dict__.iteritems()]
11795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11796 
 
11797 
  def __eq__(self, other):
11798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11799 
 
11800 
  def __ne__(self, other):
11801 
    return not (self == other)
11802 
 
3064 chandransh 11803 
class addBillingDetails_args:
1135 chandransh 11804 
  """
11805 
  Attributes:
3064 chandransh 11806 
   - orderId
11807 
   - invoice_number
4658 mandeep.dh 11808 
   - serialNumber
4283 anupam.sin 11809 
   - itemNumber
3064 chandransh 11810 
   - billed_by
4264 rajveer 11811 
   - jacketNumber
4283 anupam.sin 11812 
   - billingType
5110 mandeep.dh 11813 
   - fulfilmentWarehouseId
4763 rajveer 11814 
   - authorize
1135 chandransh 11815 
  """
11816 
 
11817 
  thrift_spec = (
11818 
    None, # 0
3064 chandransh 11819 
    (1, TType.I64, 'orderId', None, None, ), # 1
11820 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 11821 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
11822 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 11823 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11824 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11825 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11826 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11827 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11828 
  )
11829 
 
5110 mandeep.dh 11830 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 11831 
    self.orderId = orderId
11832 
    self.invoice_number = invoice_number
4658 mandeep.dh 11833 
    self.serialNumber = serialNumber
4283 anupam.sin 11834 
    self.itemNumber = itemNumber
3064 chandransh 11835 
    self.billed_by = billed_by
4264 rajveer 11836 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11837 
    self.billingType = billingType
5110 mandeep.dh 11838 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11839 
    self.authorize = authorize
1135 chandransh 11840 
 
11841 
  def read(self, iprot):
11842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11844 
      return
11845 
    iprot.readStructBegin()
11846 
    while True:
11847 
      (fname, ftype, fid) = iprot.readFieldBegin()
11848 
      if ftype == TType.STOP:
11849 
        break
11850 
      if fid == 1:
11851 
        if ftype == TType.I64:
3064 chandransh 11852 
          self.orderId = iprot.readI64();
1135 chandransh 11853 
        else:
11854 
          iprot.skip(ftype)
11855 
      elif fid == 2:
3064 chandransh 11856 
        if ftype == TType.STRING:
11857 
          self.invoice_number = iprot.readString();
1135 chandransh 11858 
        else:
11859 
          iprot.skip(ftype)
3064 chandransh 11860 
      elif fid == 3:
5411 rajveer 11861 
        if ftype == TType.LIST:
11862 
          self.serialNumber = []
11863 
          (_etype227, _size224) = iprot.readListBegin()
11864 
          for _i228 in xrange(_size224):
11865 
            _elem229 = iprot.readString();
11866 
            self.serialNumber.append(_elem229)
11867 
          iprot.readListEnd()
3064 chandransh 11868 
        else:
11869 
          iprot.skip(ftype)
11870 
      elif fid == 4:
5411 rajveer 11871 
        if ftype == TType.LIST:
11872 
          self.itemNumber = []
11873 
          (_etype233, _size230) = iprot.readListBegin()
11874 
          for _i234 in xrange(_size230):
11875 
            _elem235 = iprot.readString();
11876 
            self.itemNumber.append(_elem235)
11877 
          iprot.readListEnd()
3064 chandransh 11878 
        else:
11879 
          iprot.skip(ftype)
11880 
      elif fid == 5:
11881 
        if ftype == TType.STRING:
4283 anupam.sin 11882 
          self.billed_by = iprot.readString();
3064 chandransh 11883 
        else:
11884 
          iprot.skip(ftype)
11885 
      elif fid == 6:
11886 
        if ftype == TType.I64:
4283 anupam.sin 11887 
          self.jacketNumber = iprot.readI64();
11888 
        else:
11889 
          iprot.skip(ftype)
11890 
      elif fid == 7:
11891 
        if ftype == TType.I64:
3064 chandransh 11892 
          self.billingType = iprot.readI64();
11893 
        else:
11894 
          iprot.skip(ftype)
4283 anupam.sin 11895 
      elif fid == 8:
11896 
        if ftype == TType.I64:
5110 mandeep.dh 11897 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11898 
        else:
11899 
          iprot.skip(ftype)
4763 rajveer 11900 
      elif fid == 9:
11901 
        if ftype == TType.BOOL:
11902 
          self.authorize = iprot.readBool();
11903 
        else:
11904 
          iprot.skip(ftype)
1246 chandransh 11905 
      else:
11906 
        iprot.skip(ftype)
11907 
      iprot.readFieldEnd()
11908 
    iprot.readStructEnd()
11909 
 
11910 
  def write(self, oprot):
11911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11913 
      return
4283 anupam.sin 11914 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11915 
    if self.orderId is not None:
3064 chandransh 11916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11917 
      oprot.writeI64(self.orderId)
1246 chandransh 11918 
      oprot.writeFieldEnd()
4283 anupam.sin 11919 
    if self.invoice_number is not None:
11920 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11921 
      oprot.writeString(self.invoice_number)
1246 chandransh 11922 
      oprot.writeFieldEnd()
4658 mandeep.dh 11923 
    if self.serialNumber is not None:
5411 rajveer 11924 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
11925 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
11926 
      for iter236 in self.serialNumber:
11927 
        oprot.writeString(iter236)
11928 
      oprot.writeListEnd()
3064 chandransh 11929 
      oprot.writeFieldEnd()
3431 rajveer 11930 
    if self.itemNumber is not None:
5411 rajveer 11931 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
11932 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
11933 
      for iter237 in self.itemNumber:
11934 
        oprot.writeString(iter237)
11935 
      oprot.writeListEnd()
3064 chandransh 11936 
      oprot.writeFieldEnd()
4283 anupam.sin 11937 
    if self.billed_by is not None:
11938 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11939 
      oprot.writeString(self.billed_by)
3064 chandransh 11940 
      oprot.writeFieldEnd()
4283 anupam.sin 11941 
    if self.jacketNumber is not None:
11942 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11943 
      oprot.writeI64(self.jacketNumber)
11944 
      oprot.writeFieldEnd()
3431 rajveer 11945 
    if self.billingType is not None:
4283 anupam.sin 11946 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11947 
      oprot.writeI64(self.billingType)
11948 
      oprot.writeFieldEnd()
5110 mandeep.dh 11949 
    if self.fulfilmentWarehouseId is not None:
11950 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11951 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11952 
      oprot.writeFieldEnd()
4763 rajveer 11953 
    if self.authorize is not None:
11954 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11955 
      oprot.writeBool(self.authorize)
11956 
      oprot.writeFieldEnd()
1246 chandransh 11957 
    oprot.writeFieldStop()
11958 
    oprot.writeStructEnd()
11959 
 
3431 rajveer 11960 
  def validate(self):
11961 
    return
11962 
 
11963 
 
1246 chandransh 11964 
  def __repr__(self):
11965 
    L = ['%s=%r' % (key, value)
11966 
      for key, value in self.__dict__.iteritems()]
11967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11968 
 
11969 
  def __eq__(self, other):
11970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11971 
 
11972 
  def __ne__(self, other):
11973 
    return not (self == other)
11974 
 
4283 anupam.sin 11975 
class addBillingDetails_result:
1246 chandransh 11976 
  """
11977 
  Attributes:
3064 chandransh 11978 
   - success
1246 chandransh 11979 
   - ex
11980 
  """
11981 
 
11982 
  thrift_spec = (
3064 chandransh 11983 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11985 
  )
11986 
 
3064 chandransh 11987 
  def __init__(self, success=None, ex=None,):
11988 
    self.success = success
1246 chandransh 11989 
    self.ex = ex
11990 
 
11991 
  def read(self, iprot):
11992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11994 
      return
11995 
    iprot.readStructBegin()
11996 
    while True:
11997 
      (fname, ftype, fid) = iprot.readFieldBegin()
11998 
      if ftype == TType.STOP:
11999 
        break
3064 chandransh 12000 
      if fid == 0:
12001 
        if ftype == TType.BOOL:
12002 
          self.success = iprot.readBool();
12003 
        else:
12004 
          iprot.skip(ftype)
12005 
      elif fid == 1:
1246 chandransh 12006 
        if ftype == TType.STRUCT:
12007 
          self.ex = TransactionServiceException()
12008 
          self.ex.read(iprot)
12009 
        else:
12010 
          iprot.skip(ftype)
12011 
      else:
12012 
        iprot.skip(ftype)
12013 
      iprot.readFieldEnd()
12014 
    iprot.readStructEnd()
12015 
 
12016 
  def write(self, oprot):
12017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12019 
      return
4283 anupam.sin 12020 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12021 
    if self.success is not None:
3064 chandransh 12022 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12023 
      oprot.writeBool(self.success)
12024 
      oprot.writeFieldEnd()
3431 rajveer 12025 
    if self.ex is not None:
1246 chandransh 12026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12027 
      self.ex.write(oprot)
12028 
      oprot.writeFieldEnd()
12029 
    oprot.writeFieldStop()
12030 
    oprot.writeStructEnd()
12031 
 
3431 rajveer 12032 
  def validate(self):
12033 
    return
12034 
 
12035 
 
1246 chandransh 12036 
  def __repr__(self):
12037 
    L = ['%s=%r' % (key, value)
12038 
      for key, value in self.__dict__.iteritems()]
12039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12040 
 
12041 
  def __eq__(self, other):
12042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12043 
 
12044 
  def __ne__(self, other):
12045 
    return not (self == other)
12046 
 
4579 rajveer 12047 
class addInvoiceNumber_args:
12048 
  """
12049 
  Attributes:
12050 
   - orderId
12051 
   - invoiceNumber
4763 rajveer 12052 
   - color
4579 rajveer 12053 
  """
12054 
 
12055 
  thrift_spec = (
12056 
    None, # 0
12057 
    (1, TType.I64, 'orderId', None, None, ), # 1
12058 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12059 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12060 
  )
12061 
 
4763 rajveer 12062 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12063 
    self.orderId = orderId
12064 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12065 
    self.color = color
4579 rajveer 12066 
 
12067 
  def read(self, iprot):
12068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12070 
      return
12071 
    iprot.readStructBegin()
12072 
    while True:
12073 
      (fname, ftype, fid) = iprot.readFieldBegin()
12074 
      if ftype == TType.STOP:
12075 
        break
12076 
      if fid == 1:
12077 
        if ftype == TType.I64:
12078 
          self.orderId = iprot.readI64();
12079 
        else:
12080 
          iprot.skip(ftype)
12081 
      elif fid == 2:
12082 
        if ftype == TType.STRING:
12083 
          self.invoiceNumber = iprot.readString();
12084 
        else:
12085 
          iprot.skip(ftype)
4763 rajveer 12086 
      elif fid == 3:
12087 
        if ftype == TType.STRING:
12088 
          self.color = iprot.readString();
12089 
        else:
12090 
          iprot.skip(ftype)
4579 rajveer 12091 
      else:
12092 
        iprot.skip(ftype)
12093 
      iprot.readFieldEnd()
12094 
    iprot.readStructEnd()
12095 
 
12096 
  def write(self, oprot):
12097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12099 
      return
12100 
    oprot.writeStructBegin('addInvoiceNumber_args')
12101 
    if self.orderId is not None:
12102 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12103 
      oprot.writeI64(self.orderId)
12104 
      oprot.writeFieldEnd()
12105 
    if self.invoiceNumber is not None:
12106 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12107 
      oprot.writeString(self.invoiceNumber)
12108 
      oprot.writeFieldEnd()
4763 rajveer 12109 
    if self.color is not None:
12110 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12111 
      oprot.writeString(self.color)
12112 
      oprot.writeFieldEnd()
4579 rajveer 12113 
    oprot.writeFieldStop()
12114 
    oprot.writeStructEnd()
12115 
 
12116 
  def validate(self):
12117 
    return
12118 
 
12119 
 
12120 
  def __repr__(self):
12121 
    L = ['%s=%r' % (key, value)
12122 
      for key, value in self.__dict__.iteritems()]
12123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12124 
 
12125 
  def __eq__(self, other):
12126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12127 
 
12128 
  def __ne__(self, other):
12129 
    return not (self == other)
12130 
 
12131 
class addInvoiceNumber_result:
12132 
  """
12133 
  Attributes:
12134 
   - ex
12135 
  """
12136 
 
12137 
  thrift_spec = (
12138 
    None, # 0
12139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12140 
  )
12141 
 
12142 
  def __init__(self, ex=None,):
12143 
    self.ex = ex
12144 
 
12145 
  def read(self, iprot):
12146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12148 
      return
12149 
    iprot.readStructBegin()
12150 
    while True:
12151 
      (fname, ftype, fid) = iprot.readFieldBegin()
12152 
      if ftype == TType.STOP:
12153 
        break
12154 
      if fid == 1:
12155 
        if ftype == TType.STRUCT:
12156 
          self.ex = TransactionServiceException()
12157 
          self.ex.read(iprot)
12158 
        else:
12159 
          iprot.skip(ftype)
12160 
      else:
12161 
        iprot.skip(ftype)
12162 
      iprot.readFieldEnd()
12163 
    iprot.readStructEnd()
12164 
 
12165 
  def write(self, oprot):
12166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12168 
      return
12169 
    oprot.writeStructBegin('addInvoiceNumber_result')
12170 
    if self.ex is not None:
12171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12172 
      self.ex.write(oprot)
12173 
      oprot.writeFieldEnd()
12174 
    oprot.writeFieldStop()
12175 
    oprot.writeStructEnd()
12176 
 
12177 
  def validate(self):
12178 
    return
12179 
 
12180 
 
12181 
  def __repr__(self):
12182 
    L = ['%s=%r' % (key, value)
12183 
      for key, value in self.__dict__.iteritems()]
12184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12185 
 
12186 
  def __eq__(self, other):
12187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12188 
 
12189 
  def __ne__(self, other):
12190 
    return not (self == other)
12191 
 
4910 phani.kuma 12192 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12193 
  """
12194 
  Attributes:
3064 chandransh 12195 
   - warehouseId
1408 ankur.sing 12196 
   - providerId
3064 chandransh 12197 
   - cod
4910 phani.kuma 12198 
   - orderIds
1408 ankur.sing 12199 
  """
12200 
 
12201 
  thrift_spec = (
12202 
    None, # 0
3064 chandransh 12203 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12204 
    (2, TType.I64, 'providerId', None, None, ), # 2
12205 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12206 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12207 
  )
12208 
 
4910 phani.kuma 12209 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12210 
    self.warehouseId = warehouseId
1408 ankur.sing 12211 
    self.providerId = providerId
3064 chandransh 12212 
    self.cod = cod
4910 phani.kuma 12213 
    self.orderIds = orderIds
1408 ankur.sing 12214 
 
12215 
  def read(self, iprot):
12216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12218 
      return
12219 
    iprot.readStructBegin()
12220 
    while True:
12221 
      (fname, ftype, fid) = iprot.readFieldBegin()
12222 
      if ftype == TType.STOP:
12223 
        break
12224 
      if fid == 1:
12225 
        if ftype == TType.I64:
3064 chandransh 12226 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12227 
        else:
12228 
          iprot.skip(ftype)
12229 
      elif fid == 2:
12230 
        if ftype == TType.I64:
3064 chandransh 12231 
          self.providerId = iprot.readI64();
1408 ankur.sing 12232 
        else:
12233 
          iprot.skip(ftype)
3064 chandransh 12234 
      elif fid == 3:
12235 
        if ftype == TType.BOOL:
12236 
          self.cod = iprot.readBool();
12237 
        else:
12238 
          iprot.skip(ftype)
4910 phani.kuma 12239 
      elif fid == 4:
12240 
        if ftype == TType.LIST:
12241 
          self.orderIds = []
5411 rajveer 12242 
          (_etype241, _size238) = iprot.readListBegin()
12243 
          for _i242 in xrange(_size238):
12244 
            _elem243 = iprot.readI64();
12245 
            self.orderIds.append(_elem243)
4910 phani.kuma 12246 
          iprot.readListEnd()
12247 
        else:
12248 
          iprot.skip(ftype)
1408 ankur.sing 12249 
      else:
12250 
        iprot.skip(ftype)
12251 
      iprot.readFieldEnd()
12252 
    iprot.readStructEnd()
12253 
 
12254 
  def write(self, oprot):
12255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12257 
      return
4910 phani.kuma 12258 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12259 
    if self.warehouseId is not None:
3064 chandransh 12260 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12261 
      oprot.writeI64(self.warehouseId)
12262 
      oprot.writeFieldEnd()
3431 rajveer 12263 
    if self.providerId is not None:
3064 chandransh 12264 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12265 
      oprot.writeI64(self.providerId)
12266 
      oprot.writeFieldEnd()
3431 rajveer 12267 
    if self.cod is not None:
3064 chandransh 12268 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12269 
      oprot.writeBool(self.cod)
1408 ankur.sing 12270 
      oprot.writeFieldEnd()
4910 phani.kuma 12271 
    if self.orderIds is not None:
12272 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12273 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12274 
      for iter244 in self.orderIds:
12275 
        oprot.writeI64(iter244)
4910 phani.kuma 12276 
      oprot.writeListEnd()
12277 
      oprot.writeFieldEnd()
1408 ankur.sing 12278 
    oprot.writeFieldStop()
12279 
    oprot.writeStructEnd()
12280 
 
3431 rajveer 12281 
  def validate(self):
12282 
    return
12283 
 
12284 
 
1408 ankur.sing 12285 
  def __repr__(self):
12286 
    L = ['%s=%r' % (key, value)
12287 
      for key, value in self.__dict__.iteritems()]
12288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12289 
 
12290 
  def __eq__(self, other):
12291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12292 
 
12293 
  def __ne__(self, other):
12294 
    return not (self == other)
12295 
 
4910 phani.kuma 12296 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12297 
  """
12298 
  Attributes:
12299 
   - success
3064 chandransh 12300 
   - ex
1408 ankur.sing 12301 
  """
12302 
 
12303 
  thrift_spec = (
3064 chandransh 12304 
    (0, TType.BOOL, 'success', None, None, ), # 0
12305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12306 
  )
12307 
 
3064 chandransh 12308 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12309 
    self.success = success
3064 chandransh 12310 
    self.ex = ex
1408 ankur.sing 12311 
 
12312 
  def read(self, iprot):
12313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12315 
      return
12316 
    iprot.readStructBegin()
12317 
    while True:
12318 
      (fname, ftype, fid) = iprot.readFieldBegin()
12319 
      if ftype == TType.STOP:
12320 
        break
12321 
      if fid == 0:
3064 chandransh 12322 
        if ftype == TType.BOOL:
12323 
          self.success = iprot.readBool();
1408 ankur.sing 12324 
        else:
12325 
          iprot.skip(ftype)
3064 chandransh 12326 
      elif fid == 1:
12327 
        if ftype == TType.STRUCT:
12328 
          self.ex = TransactionServiceException()
12329 
          self.ex.read(iprot)
12330 
        else:
12331 
          iprot.skip(ftype)
1408 ankur.sing 12332 
      else:
12333 
        iprot.skip(ftype)
12334 
      iprot.readFieldEnd()
12335 
    iprot.readStructEnd()
12336 
 
12337 
  def write(self, oprot):
12338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12340 
      return
4910 phani.kuma 12341 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12342 
    if self.success is not None:
3064 chandransh 12343 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12344 
      oprot.writeBool(self.success)
1408 ankur.sing 12345 
      oprot.writeFieldEnd()
3431 rajveer 12346 
    if self.ex is not None:
3064 chandransh 12347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12348 
      self.ex.write(oprot)
12349 
      oprot.writeFieldEnd()
1408 ankur.sing 12350 
    oprot.writeFieldStop()
12351 
    oprot.writeStructEnd()
12352 
 
3431 rajveer 12353 
  def validate(self):
12354 
    return
12355 
 
12356 
 
1408 ankur.sing 12357 
  def __repr__(self):
12358 
    L = ['%s=%r' % (key, value)
12359 
      for key, value in self.__dict__.iteritems()]
12360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12361 
 
12362 
  def __eq__(self, other):
12363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12364 
 
12365 
  def __ne__(self, other):
12366 
    return not (self == other)
12367 
 
4910 phani.kuma 12368 
class markOrdersAsPickedUp_args:
4410 rajveer 12369 
  """
12370 
  Attributes:
12371 
   - providerId
4910 phani.kuma 12372 
   - pickupDetails
4410 rajveer 12373 
  """
12374 
 
12375 
  thrift_spec = (
12376 
    None, # 0
4910 phani.kuma 12377 
    (1, TType.I64, 'providerId', None, None, ), # 1
12378 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12379 
  )
12380 
 
4910 phani.kuma 12381 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12382 
    self.providerId = providerId
4910 phani.kuma 12383 
    self.pickupDetails = pickupDetails
4410 rajveer 12384 
 
12385 
  def read(self, iprot):
12386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12388 
      return
12389 
    iprot.readStructBegin()
12390 
    while True:
12391 
      (fname, ftype, fid) = iprot.readFieldBegin()
12392 
      if ftype == TType.STOP:
12393 
        break
12394 
      if fid == 1:
12395 
        if ftype == TType.I64:
4910 phani.kuma 12396 
          self.providerId = iprot.readI64();
4410 rajveer 12397 
        else:
12398 
          iprot.skip(ftype)
12399 
      elif fid == 2:
4910 phani.kuma 12400 
        if ftype == TType.MAP:
12401 
          self.pickupDetails = {}
5411 rajveer 12402 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
12403 
          for _i249 in xrange(_size245):
12404 
            _key250 = iprot.readString();
12405 
            _val251 = iprot.readString();
12406 
            self.pickupDetails[_key250] = _val251
4910 phani.kuma 12407 
          iprot.readMapEnd()
4410 rajveer 12408 
        else:
12409 
          iprot.skip(ftype)
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
4910 phani.kuma 12419 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12420 
    if self.providerId is not None:
4910 phani.kuma 12421 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12422 
      oprot.writeI64(self.providerId)
12423 
      oprot.writeFieldEnd()
4910 phani.kuma 12424 
    if self.pickupDetails is not None:
12425 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12426 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 12427 
      for kiter252,viter253 in self.pickupDetails.items():
12428 
        oprot.writeString(kiter252)
12429 
        oprot.writeString(viter253)
4910 phani.kuma 12430 
      oprot.writeMapEnd()
4410 rajveer 12431 
      oprot.writeFieldEnd()
12432 
    oprot.writeFieldStop()
12433 
    oprot.writeStructEnd()
12434 
 
12435 
  def validate(self):
12436 
    return
12437 
 
12438 
 
12439 
  def __repr__(self):
12440 
    L = ['%s=%r' % (key, value)
12441 
      for key, value in self.__dict__.iteritems()]
12442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12443 
 
12444 
  def __eq__(self, other):
12445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12446 
 
12447 
  def __ne__(self, other):
12448 
    return not (self == other)
12449 
 
4910 phani.kuma 12450 
class markOrdersAsPickedUp_result:
4410 rajveer 12451 
  """
12452 
  Attributes:
12453 
   - ex
12454 
  """
12455 
 
12456 
  thrift_spec = (
4910 phani.kuma 12457 
    None, # 0
4410 rajveer 12458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12459 
  )
12460 
 
4910 phani.kuma 12461 
  def __init__(self, ex=None,):
4410 rajveer 12462 
    self.ex = ex
12463 
 
12464 
  def read(self, iprot):
12465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12467 
      return
12468 
    iprot.readStructBegin()
12469 
    while True:
12470 
      (fname, ftype, fid) = iprot.readFieldBegin()
12471 
      if ftype == TType.STOP:
12472 
        break
4910 phani.kuma 12473 
      if fid == 1:
4410 rajveer 12474 
        if ftype == TType.STRUCT:
12475 
          self.ex = TransactionServiceException()
12476 
          self.ex.read(iprot)
12477 
        else:
12478 
          iprot.skip(ftype)
12479 
      else:
12480 
        iprot.skip(ftype)
12481 
      iprot.readFieldEnd()
12482 
    iprot.readStructEnd()
12483 
 
12484 
  def write(self, oprot):
12485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12487 
      return
4910 phani.kuma 12488 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12489 
    if self.ex is not None:
12490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12491 
      self.ex.write(oprot)
12492 
      oprot.writeFieldEnd()
12493 
    oprot.writeFieldStop()
12494 
    oprot.writeStructEnd()
12495 
 
12496 
  def validate(self):
12497 
    return
12498 
 
12499 
 
12500 
  def __repr__(self):
12501 
    L = ['%s=%r' % (key, value)
12502 
      for key, value in self.__dict__.iteritems()]
12503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12504 
 
12505 
  def __eq__(self, other):
12506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12507 
 
12508 
  def __ne__(self, other):
12509 
    return not (self == other)
12510 
 
4910 phani.kuma 12511 
class getOrdersNotPickedUp_args:
304 ashish 12512 
  """
12513 
  Attributes:
3064 chandransh 12514 
   - providerId
304 ashish 12515 
  """
94 ashish 12516 
 
304 ashish 12517 
  thrift_spec = (
12518 
    None, # 0
3064 chandransh 12519 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12520 
  )
12521 
 
4910 phani.kuma 12522 
  def __init__(self, providerId=None,):
3064 chandransh 12523 
    self.providerId = providerId
304 ashish 12524 
 
12525 
  def read(self, iprot):
12526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12528 
      return
12529 
    iprot.readStructBegin()
12530 
    while True:
12531 
      (fname, ftype, fid) = iprot.readFieldBegin()
12532 
      if ftype == TType.STOP:
12533 
        break
12534 
      if fid == 1:
12535 
        if ftype == TType.I64:
3064 chandransh 12536 
          self.providerId = iprot.readI64();
304 ashish 12537 
        else:
12538 
          iprot.skip(ftype)
12539 
      else:
12540 
        iprot.skip(ftype)
12541 
      iprot.readFieldEnd()
12542 
    iprot.readStructEnd()
12543 
 
12544 
  def write(self, oprot):
12545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12547 
      return
4910 phani.kuma 12548 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12549 
    if self.providerId is not None:
3064 chandransh 12550 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12551 
      oprot.writeI64(self.providerId)
304 ashish 12552 
      oprot.writeFieldEnd()
12553 
    oprot.writeFieldStop()
12554 
    oprot.writeStructEnd()
12555 
 
3431 rajveer 12556 
  def validate(self):
12557 
    return
12558 
 
12559 
 
304 ashish 12560 
  def __repr__(self):
12561 
    L = ['%s=%r' % (key, value)
12562 
      for key, value in self.__dict__.iteritems()]
12563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12564 
 
12565 
  def __eq__(self, other):
12566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12567 
 
12568 
  def __ne__(self, other):
12569 
    return not (self == other)
12570 
 
4910 phani.kuma 12571 
class getOrdersNotPickedUp_result:
304 ashish 12572 
  """
12573 
  Attributes:
12574 
   - success
12575 
  """
12576 
 
12577 
  thrift_spec = (
3064 chandransh 12578 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12579 
  )
12580 
 
4910 phani.kuma 12581 
  def __init__(self, success=None,):
304 ashish 12582 
    self.success = success
12583 
 
12584 
  def read(self, iprot):
12585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12587 
      return
12588 
    iprot.readStructBegin()
12589 
    while True:
12590 
      (fname, ftype, fid) = iprot.readFieldBegin()
12591 
      if ftype == TType.STOP:
12592 
        break
12593 
      if fid == 0:
12594 
        if ftype == TType.LIST:
12595 
          self.success = []
5411 rajveer 12596 
          (_etype257, _size254) = iprot.readListBegin()
12597 
          for _i258 in xrange(_size254):
12598 
            _elem259 = Order()
12599 
            _elem259.read(iprot)
12600 
            self.success.append(_elem259)
304 ashish 12601 
          iprot.readListEnd()
12602 
        else:
12603 
          iprot.skip(ftype)
12604 
      else:
12605 
        iprot.skip(ftype)
12606 
      iprot.readFieldEnd()
12607 
    iprot.readStructEnd()
12608 
 
12609 
  def write(self, oprot):
12610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12612 
      return
4910 phani.kuma 12613 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12614 
    if self.success is not None:
304 ashish 12615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12617 
      for iter260 in self.success:
12618 
        iter260.write(oprot)
304 ashish 12619 
      oprot.writeListEnd()
12620 
      oprot.writeFieldEnd()
12621 
    oprot.writeFieldStop()
12622 
    oprot.writeStructEnd()
12623 
 
3431 rajveer 12624 
  def validate(self):
12625 
    return
12626 
 
12627 
 
304 ashish 12628 
  def __repr__(self):
12629 
    L = ['%s=%r' % (key, value)
12630 
      for key, value in self.__dict__.iteritems()]
12631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12632 
 
12633 
  def __eq__(self, other):
12634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12635 
 
12636 
  def __ne__(self, other):
12637 
    return not (self == other)
12638 
 
3064 chandransh 12639 
class markOrdersAsDelivered_args:
304 ashish 12640 
  """
12641 
  Attributes:
3064 chandransh 12642 
   - providerId
12643 
   - deliveredOrders
304 ashish 12644 
  """
12645 
 
12646 
  thrift_spec = (
12647 
    None, # 0
3064 chandransh 12648 
    (1, TType.I64, 'providerId', None, None, ), # 1
12649 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12650 
  )
12651 
 
3064 chandransh 12652 
  def __init__(self, providerId=None, deliveredOrders=None,):
12653 
    self.providerId = providerId
12654 
    self.deliveredOrders = deliveredOrders
304 ashish 12655 
 
12656 
  def read(self, iprot):
12657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12659 
      return
12660 
    iprot.readStructBegin()
12661 
    while True:
12662 
      (fname, ftype, fid) = iprot.readFieldBegin()
12663 
      if ftype == TType.STOP:
12664 
        break
12665 
      if fid == 1:
12666 
        if ftype == TType.I64:
3064 chandransh 12667 
          self.providerId = iprot.readI64();
304 ashish 12668 
        else:
12669 
          iprot.skip(ftype)
12670 
      elif fid == 2:
3064 chandransh 12671 
        if ftype == TType.MAP:
12672 
          self.deliveredOrders = {}
5411 rajveer 12673 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
12674 
          for _i265 in xrange(_size261):
12675 
            _key266 = iprot.readString();
12676 
            _val267 = iprot.readString();
12677 
            self.deliveredOrders[_key266] = _val267
3064 chandransh 12678 
          iprot.readMapEnd()
304 ashish 12679 
        else:
12680 
          iprot.skip(ftype)
12681 
      else:
12682 
        iprot.skip(ftype)
12683 
      iprot.readFieldEnd()
12684 
    iprot.readStructEnd()
12685 
 
12686 
  def write(self, oprot):
12687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12689 
      return
3064 chandransh 12690 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12691 
    if self.providerId is not None:
3064 chandransh 12692 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12693 
      oprot.writeI64(self.providerId)
304 ashish 12694 
      oprot.writeFieldEnd()
3431 rajveer 12695 
    if self.deliveredOrders is not None:
3064 chandransh 12696 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12697 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5411 rajveer 12698 
      for kiter268,viter269 in self.deliveredOrders.items():
12699 
        oprot.writeString(kiter268)
12700 
        oprot.writeString(viter269)
3064 chandransh 12701 
      oprot.writeMapEnd()
304 ashish 12702 
      oprot.writeFieldEnd()
12703 
    oprot.writeFieldStop()
12704 
    oprot.writeStructEnd()
12705 
 
3431 rajveer 12706 
  def validate(self):
12707 
    return
12708 
 
12709 
 
304 ashish 12710 
  def __repr__(self):
12711 
    L = ['%s=%r' % (key, value)
12712 
      for key, value in self.__dict__.iteritems()]
12713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12714 
 
12715 
  def __eq__(self, other):
12716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12717 
 
12718 
  def __ne__(self, other):
12719 
    return not (self == other)
12720 
 
3064 chandransh 12721 
class markOrdersAsDelivered_result:
12722 
  """
12723 
  Attributes:
12724 
   - ex
12725 
  """
304 ashish 12726 
 
12727 
  thrift_spec = (
3064 chandransh 12728 
    None, # 0
12729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12730 
  )
12731 
 
3064 chandransh 12732 
  def __init__(self, ex=None,):
12733 
    self.ex = ex
304 ashish 12734 
 
1596 ankur.sing 12735 
  def read(self, iprot):
12736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12738 
      return
12739 
    iprot.readStructBegin()
12740 
    while True:
12741 
      (fname, ftype, fid) = iprot.readFieldBegin()
12742 
      if ftype == TType.STOP:
12743 
        break
3064 chandransh 12744 
      if fid == 1:
12745 
        if ftype == TType.STRUCT:
12746 
          self.ex = TransactionServiceException()
12747 
          self.ex.read(iprot)
12748 
        else:
12749 
          iprot.skip(ftype)
1596 ankur.sing 12750 
      else:
12751 
        iprot.skip(ftype)
12752 
      iprot.readFieldEnd()
12753 
    iprot.readStructEnd()
12754 
 
12755 
  def write(self, oprot):
12756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12758 
      return
3064 chandransh 12759 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12760 
    if self.ex is not None:
3064 chandransh 12761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12762 
      self.ex.write(oprot)
12763 
      oprot.writeFieldEnd()
1596 ankur.sing 12764 
    oprot.writeFieldStop()
12765 
    oprot.writeStructEnd()
12766 
 
3431 rajveer 12767 
  def validate(self):
12768 
    return
12769 
 
12770 
 
1596 ankur.sing 12771 
  def __repr__(self):
12772 
    L = ['%s=%r' % (key, value)
12773 
      for key, value in self.__dict__.iteritems()]
12774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12775 
 
12776 
  def __eq__(self, other):
12777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12778 
 
12779 
  def __ne__(self, other):
12780 
    return not (self == other)
12781 
 
4910 phani.kuma 12782 
class markAsRTOrders_args:
1596 ankur.sing 12783 
  """
12784 
  Attributes:
3064 chandransh 12785 
   - providerId
12786 
   - returnedOrders
1596 ankur.sing 12787 
  """
12788 
 
12789 
  thrift_spec = (
3064 chandransh 12790 
    None, # 0
12791 
    (1, TType.I64, 'providerId', None, None, ), # 1
12792 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12793 
  )
12794 
 
3064 chandransh 12795 
  def __init__(self, providerId=None, returnedOrders=None,):
12796 
    self.providerId = providerId
12797 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12798 
 
12799 
  def read(self, iprot):
12800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12802 
      return
12803 
    iprot.readStructBegin()
12804 
    while True:
12805 
      (fname, ftype, fid) = iprot.readFieldBegin()
12806 
      if ftype == TType.STOP:
12807 
        break
3064 chandransh 12808 
      if fid == 1:
1596 ankur.sing 12809 
        if ftype == TType.I64:
3064 chandransh 12810 
          self.providerId = iprot.readI64();
1596 ankur.sing 12811 
        else:
12812 
          iprot.skip(ftype)
3064 chandransh 12813 
      elif fid == 2:
12814 
        if ftype == TType.MAP:
12815 
          self.returnedOrders = {}
5411 rajveer 12816 
          (_ktype271, _vtype272, _size270 ) = iprot.readMapBegin()
12817 
          for _i274 in xrange(_size270):
12818 
            _key275 = iprot.readString();
12819 
            _val276 = iprot.readString();
12820 
            self.returnedOrders[_key275] = _val276
3064 chandransh 12821 
          iprot.readMapEnd()
12822 
        else:
12823 
          iprot.skip(ftype)
1596 ankur.sing 12824 
      else:
12825 
        iprot.skip(ftype)
12826 
      iprot.readFieldEnd()
12827 
    iprot.readStructEnd()
12828 
 
12829 
  def write(self, oprot):
12830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12832 
      return
4910 phani.kuma 12833 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12834 
    if self.providerId is not None:
3064 chandransh 12835 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12836 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12837 
      oprot.writeFieldEnd()
3431 rajveer 12838 
    if self.returnedOrders is not None:
3064 chandransh 12839 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12840 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5411 rajveer 12841 
      for kiter277,viter278 in self.returnedOrders.items():
12842 
        oprot.writeString(kiter277)
12843 
        oprot.writeString(viter278)
3064 chandransh 12844 
      oprot.writeMapEnd()
12845 
      oprot.writeFieldEnd()
1596 ankur.sing 12846 
    oprot.writeFieldStop()
12847 
    oprot.writeStructEnd()
12848 
 
3431 rajveer 12849 
  def validate(self):
12850 
    return
12851 
 
12852 
 
1596 ankur.sing 12853 
  def __repr__(self):
12854 
    L = ['%s=%r' % (key, value)
12855 
      for key, value in self.__dict__.iteritems()]
12856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12857 
 
12858 
  def __eq__(self, other):
12859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12860 
 
12861 
  def __ne__(self, other):
12862 
    return not (self == other)
12863 
 
4910 phani.kuma 12864 
class markAsRTOrders_result:
3064 chandransh 12865 
  """
12866 
  Attributes:
12867 
   - ex
12868 
  """
1596 ankur.sing 12869 
 
1627 ankur.sing 12870 
  thrift_spec = (
3064 chandransh 12871 
    None, # 0
12872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12873 
  )
12874 
 
3064 chandransh 12875 
  def __init__(self, ex=None,):
12876 
    self.ex = ex
12877 
 
1627 ankur.sing 12878 
  def read(self, iprot):
12879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12881 
      return
12882 
    iprot.readStructBegin()
12883 
    while True:
12884 
      (fname, ftype, fid) = iprot.readFieldBegin()
12885 
      if ftype == TType.STOP:
12886 
        break
3064 chandransh 12887 
      if fid == 1:
12888 
        if ftype == TType.STRUCT:
12889 
          self.ex = TransactionServiceException()
12890 
          self.ex.read(iprot)
12891 
        else:
12892 
          iprot.skip(ftype)
1627 ankur.sing 12893 
      else:
12894 
        iprot.skip(ftype)
12895 
      iprot.readFieldEnd()
12896 
    iprot.readStructEnd()
12897 
 
12898 
  def write(self, oprot):
12899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12901 
      return
4910 phani.kuma 12902 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12903 
    if self.ex is not None:
3064 chandransh 12904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12905 
      self.ex.write(oprot)
12906 
      oprot.writeFieldEnd()
1627 ankur.sing 12907 
    oprot.writeFieldStop()
12908 
    oprot.writeStructEnd()
12909 
 
3431 rajveer 12910 
  def validate(self):
12911 
    return
12912 
 
12913 
 
1627 ankur.sing 12914 
  def __repr__(self):
12915 
    L = ['%s=%r' % (key, value)
12916 
      for key, value in self.__dict__.iteritems()]
12917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12918 
 
12919 
  def __eq__(self, other):
12920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12921 
 
12922 
  def __ne__(self, other):
12923 
    return not (self == other)
12924 
 
4910 phani.kuma 12925 
class getRTOrders_args:
12926 
  """
12927 
  Attributes:
12928 
   - providerId
12929 
  """
12930 
 
12931 
  thrift_spec = (
12932 
    None, # 0
12933 
    (1, TType.I64, 'providerId', None, None, ), # 1
12934 
  )
12935 
 
12936 
  def __init__(self, providerId=None,):
12937 
    self.providerId = providerId
12938 
 
12939 
  def read(self, iprot):
12940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12942 
      return
12943 
    iprot.readStructBegin()
12944 
    while True:
12945 
      (fname, ftype, fid) = iprot.readFieldBegin()
12946 
      if ftype == TType.STOP:
12947 
        break
12948 
      if fid == 1:
12949 
        if ftype == TType.I64:
12950 
          self.providerId = iprot.readI64();
12951 
        else:
12952 
          iprot.skip(ftype)
12953 
      else:
12954 
        iprot.skip(ftype)
12955 
      iprot.readFieldEnd()
12956 
    iprot.readStructEnd()
12957 
 
12958 
  def write(self, oprot):
12959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12961 
      return
12962 
    oprot.writeStructBegin('getRTOrders_args')
12963 
    if self.providerId is not None:
12964 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12965 
      oprot.writeI64(self.providerId)
12966 
      oprot.writeFieldEnd()
12967 
    oprot.writeFieldStop()
12968 
    oprot.writeStructEnd()
12969 
 
12970 
  def validate(self):
12971 
    return
12972 
 
12973 
 
12974 
  def __repr__(self):
12975 
    L = ['%s=%r' % (key, value)
12976 
      for key, value in self.__dict__.iteritems()]
12977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12978 
 
12979 
  def __eq__(self, other):
12980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12981 
 
12982 
  def __ne__(self, other):
12983 
    return not (self == other)
12984 
 
12985 
class getRTOrders_result:
12986 
  """
12987 
  Attributes:
12988 
   - success
12989 
  """
12990 
 
12991 
  thrift_spec = (
12992 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12993 
  )
12994 
 
12995 
  def __init__(self, success=None,):
12996 
    self.success = success
12997 
 
12998 
  def read(self, iprot):
12999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13001 
      return
13002 
    iprot.readStructBegin()
13003 
    while True:
13004 
      (fname, ftype, fid) = iprot.readFieldBegin()
13005 
      if ftype == TType.STOP:
13006 
        break
13007 
      if fid == 0:
13008 
        if ftype == TType.LIST:
13009 
          self.success = []
5411 rajveer 13010 
          (_etype282, _size279) = iprot.readListBegin()
13011 
          for _i283 in xrange(_size279):
13012 
            _elem284 = Order()
13013 
            _elem284.read(iprot)
13014 
            self.success.append(_elem284)
4910 phani.kuma 13015 
          iprot.readListEnd()
13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
13027 
    oprot.writeStructBegin('getRTOrders_result')
13028 
    if self.success is not None:
13029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13030 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13031 
      for iter285 in self.success:
13032 
        iter285.write(oprot)
4910 phani.kuma 13033 
      oprot.writeListEnd()
13034 
      oprot.writeFieldEnd()
13035 
    oprot.writeFieldStop()
13036 
    oprot.writeStructEnd()
13037 
 
13038 
  def validate(self):
13039 
    return
13040 
 
13041 
 
13042 
  def __repr__(self):
13043 
    L = ['%s=%r' % (key, value)
13044 
      for key, value in self.__dict__.iteritems()]
13045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13046 
 
13047 
  def __eq__(self, other):
13048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13049 
 
13050 
  def __ne__(self, other):
13051 
    return not (self == other)
13052 
 
3064 chandransh 13053 
class updateNonDeliveryReason_args:
1627 ankur.sing 13054 
  """
13055 
  Attributes:
3064 chandransh 13056 
   - providerId
13057 
   - undeliveredOrders
1627 ankur.sing 13058 
  """
13059 
 
13060 
  thrift_spec = (
3064 chandransh 13061 
    None, # 0
13062 
    (1, TType.I64, 'providerId', None, None, ), # 1
13063 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13064 
  )
13065 
 
3064 chandransh 13066 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13067 
    self.providerId = providerId
13068 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13069 
 
13070 
  def read(self, iprot):
13071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13073 
      return
13074 
    iprot.readStructBegin()
13075 
    while True:
13076 
      (fname, ftype, fid) = iprot.readFieldBegin()
13077 
      if ftype == TType.STOP:
13078 
        break
3064 chandransh 13079 
      if fid == 1:
1627 ankur.sing 13080 
        if ftype == TType.I64:
3064 chandransh 13081 
          self.providerId = iprot.readI64();
1627 ankur.sing 13082 
        else:
13083 
          iprot.skip(ftype)
3064 chandransh 13084 
      elif fid == 2:
13085 
        if ftype == TType.MAP:
13086 
          self.undeliveredOrders = {}
5411 rajveer 13087 
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin()
13088 
          for _i290 in xrange(_size286):
13089 
            _key291 = iprot.readString();
13090 
            _val292 = iprot.readString();
13091 
            self.undeliveredOrders[_key291] = _val292
3064 chandransh 13092 
          iprot.readMapEnd()
13093 
        else:
13094 
          iprot.skip(ftype)
1627 ankur.sing 13095 
      else:
13096 
        iprot.skip(ftype)
13097 
      iprot.readFieldEnd()
13098 
    iprot.readStructEnd()
13099 
 
13100 
  def write(self, oprot):
13101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13103 
      return
3064 chandransh 13104 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13105 
    if self.providerId is not None:
3064 chandransh 13106 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13107 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13108 
      oprot.writeFieldEnd()
3431 rajveer 13109 
    if self.undeliveredOrders is not None:
3064 chandransh 13110 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13111 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5411 rajveer 13112 
      for kiter293,viter294 in self.undeliveredOrders.items():
13113 
        oprot.writeString(kiter293)
13114 
        oprot.writeString(viter294)
3064 chandransh 13115 
      oprot.writeMapEnd()
13116 
      oprot.writeFieldEnd()
1627 ankur.sing 13117 
    oprot.writeFieldStop()
13118 
    oprot.writeStructEnd()
13119 
 
3431 rajveer 13120 
  def validate(self):
13121 
    return
13122 
 
13123 
 
1627 ankur.sing 13124 
  def __repr__(self):
13125 
    L = ['%s=%r' % (key, value)
13126 
      for key, value in self.__dict__.iteritems()]
13127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13128 
 
13129 
  def __eq__(self, other):
13130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13131 
 
13132 
  def __ne__(self, other):
13133 
    return not (self == other)
13134 
 
3064 chandransh 13135 
class updateNonDeliveryReason_result:
1627 ankur.sing 13136 
  """
13137 
  Attributes:
3064 chandransh 13138 
   - ex
1627 ankur.sing 13139 
  """
13140 
 
13141 
  thrift_spec = (
4910 phani.kuma 13142 
    None, # 0
3064 chandransh 13143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13144 
  )
13145 
 
4910 phani.kuma 13146 
  def __init__(self, ex=None,):
3064 chandransh 13147 
    self.ex = ex
1627 ankur.sing 13148 
 
13149 
  def read(self, iprot):
13150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13152 
      return
13153 
    iprot.readStructBegin()
13154 
    while True:
13155 
      (fname, ftype, fid) = iprot.readFieldBegin()
13156 
      if ftype == TType.STOP:
13157 
        break
4910 phani.kuma 13158 
      if fid == 1:
13159 
        if ftype == TType.STRUCT:
13160 
          self.ex = TransactionServiceException()
13161 
          self.ex.read(iprot)
13162 
        else:
13163 
          iprot.skip(ftype)
13164 
      else:
13165 
        iprot.skip(ftype)
13166 
      iprot.readFieldEnd()
13167 
    iprot.readStructEnd()
13168 
 
13169 
  def write(self, oprot):
13170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13172 
      return
13173 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13174 
    if self.ex is not None:
13175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13176 
      self.ex.write(oprot)
13177 
      oprot.writeFieldEnd()
13178 
    oprot.writeFieldStop()
13179 
    oprot.writeStructEnd()
13180 
 
13181 
  def validate(self):
13182 
    return
13183 
 
13184 
 
13185 
  def __repr__(self):
13186 
    L = ['%s=%r' % (key, value)
13187 
      for key, value in self.__dict__.iteritems()]
13188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13189 
 
13190 
  def __eq__(self, other):
13191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13192 
 
13193 
  def __ne__(self, other):
13194 
    return not (self == other)
13195 
 
13196 
class getNonDeliveredOrdersbyCourier_args:
13197 
  """
13198 
  Attributes:
13199 
   - providerId
13200 
  """
13201 
 
13202 
  thrift_spec = (
13203 
    None, # 0
13204 
    (1, TType.I64, 'providerId', None, None, ), # 1
13205 
  )
13206 
 
13207 
  def __init__(self, providerId=None,):
13208 
    self.providerId = providerId
13209 
 
13210 
  def read(self, iprot):
13211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13213 
      return
13214 
    iprot.readStructBegin()
13215 
    while True:
13216 
      (fname, ftype, fid) = iprot.readFieldBegin()
13217 
      if ftype == TType.STOP:
13218 
        break
13219 
      if fid == 1:
13220 
        if ftype == TType.I64:
13221 
          self.providerId = iprot.readI64();
13222 
        else:
13223 
          iprot.skip(ftype)
13224 
      else:
13225 
        iprot.skip(ftype)
13226 
      iprot.readFieldEnd()
13227 
    iprot.readStructEnd()
13228 
 
13229 
  def write(self, oprot):
13230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13232 
      return
13233 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13234 
    if self.providerId is not None:
13235 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13236 
      oprot.writeI64(self.providerId)
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 
 
13256 
class getNonDeliveredOrdersbyCourier_result:
13257 
  """
13258 
  Attributes:
13259 
   - success
13260 
  """
13261 
 
13262 
  thrift_spec = (
13263 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13264 
  )
13265 
 
13266 
  def __init__(self, success=None,):
13267 
    self.success = success
13268 
 
13269 
  def read(self, iprot):
13270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13272 
      return
13273 
    iprot.readStructBegin()
13274 
    while True:
13275 
      (fname, ftype, fid) = iprot.readFieldBegin()
13276 
      if ftype == TType.STOP:
13277 
        break
4581 phani.kuma 13278 
      if fid == 0:
13279 
        if ftype == TType.LIST:
13280 
          self.success = []
5411 rajveer 13281 
          (_etype298, _size295) = iprot.readListBegin()
13282 
          for _i299 in xrange(_size295):
13283 
            _elem300 = Order()
13284 
            _elem300.read(iprot)
13285 
            self.success.append(_elem300)
4581 phani.kuma 13286 
          iprot.readListEnd()
13287 
        else:
13288 
          iprot.skip(ftype)
4910 phani.kuma 13289 
      else:
13290 
        iprot.skip(ftype)
13291 
      iprot.readFieldEnd()
13292 
    iprot.readStructEnd()
13293 
 
13294 
  def write(self, oprot):
13295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13297 
      return
13298 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13299 
    if self.success is not None:
13300 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13301 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13302 
      for iter301 in self.success:
13303 
        iter301.write(oprot)
4910 phani.kuma 13304 
      oprot.writeListEnd()
13305 
      oprot.writeFieldEnd()
13306 
    oprot.writeFieldStop()
13307 
    oprot.writeStructEnd()
13308 
 
13309 
  def validate(self):
13310 
    return
13311 
 
13312 
 
13313 
  def __repr__(self):
13314 
    L = ['%s=%r' % (key, value)
13315 
      for key, value in self.__dict__.iteritems()]
13316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13317 
 
13318 
  def __eq__(self, other):
13319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13320 
 
13321 
  def __ne__(self, other):
13322 
    return not (self == other)
13323 
 
13324 
class markOrdersAsLocalConnected_args:
13325 
  """
13326 
  Attributes:
13327 
   - providerId
13328 
   - local_connected_orders
13329 
  """
13330 
 
13331 
  thrift_spec = (
13332 
    None, # 0
13333 
    (1, TType.I64, 'providerId', None, None, ), # 1
13334 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13335 
  )
13336 
 
13337 
  def __init__(self, providerId=None, local_connected_orders=None,):
13338 
    self.providerId = providerId
13339 
    self.local_connected_orders = local_connected_orders
13340 
 
13341 
  def read(self, iprot):
13342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13344 
      return
13345 
    iprot.readStructBegin()
13346 
    while True:
13347 
      (fname, ftype, fid) = iprot.readFieldBegin()
13348 
      if ftype == TType.STOP:
13349 
        break
13350 
      if fid == 1:
13351 
        if ftype == TType.I64:
13352 
          self.providerId = iprot.readI64();
13353 
        else:
13354 
          iprot.skip(ftype)
13355 
      elif fid == 2:
13356 
        if ftype == TType.MAP:
13357 
          self.local_connected_orders = {}
5411 rajveer 13358 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
13359 
          for _i306 in xrange(_size302):
13360 
            _key307 = iprot.readString();
13361 
            _val308 = iprot.readString();
13362 
            self.local_connected_orders[_key307] = _val308
4910 phani.kuma 13363 
          iprot.readMapEnd()
13364 
        else:
13365 
          iprot.skip(ftype)
13366 
      else:
13367 
        iprot.skip(ftype)
13368 
      iprot.readFieldEnd()
13369 
    iprot.readStructEnd()
13370 
 
13371 
  def write(self, oprot):
13372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13374 
      return
13375 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13376 
    if self.providerId is not None:
13377 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13378 
      oprot.writeI64(self.providerId)
13379 
      oprot.writeFieldEnd()
13380 
    if self.local_connected_orders is not None:
13381 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13382 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5411 rajveer 13383 
      for kiter309,viter310 in self.local_connected_orders.items():
13384 
        oprot.writeString(kiter309)
13385 
        oprot.writeString(viter310)
4910 phani.kuma 13386 
      oprot.writeMapEnd()
13387 
      oprot.writeFieldEnd()
13388 
    oprot.writeFieldStop()
13389 
    oprot.writeStructEnd()
13390 
 
13391 
  def validate(self):
13392 
    return
13393 
 
13394 
 
13395 
  def __repr__(self):
13396 
    L = ['%s=%r' % (key, value)
13397 
      for key, value in self.__dict__.iteritems()]
13398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13399 
 
13400 
  def __eq__(self, other):
13401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13402 
 
13403 
  def __ne__(self, other):
13404 
    return not (self == other)
13405 
 
13406 
class markOrdersAsLocalConnected_result:
13407 
  """
13408 
  Attributes:
13409 
   - ex
13410 
  """
13411 
 
13412 
  thrift_spec = (
13413 
    None, # 0
13414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13415 
  )
13416 
 
13417 
  def __init__(self, ex=None,):
13418 
    self.ex = ex
13419 
 
13420 
  def read(self, iprot):
13421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13423 
      return
13424 
    iprot.readStructBegin()
13425 
    while True:
13426 
      (fname, ftype, fid) = iprot.readFieldBegin()
13427 
      if ftype == TType.STOP:
13428 
        break
13429 
      if fid == 1:
3064 chandransh 13430 
        if ftype == TType.STRUCT:
13431 
          self.ex = TransactionServiceException()
13432 
          self.ex.read(iprot)
1627 ankur.sing 13433 
        else:
13434 
          iprot.skip(ftype)
13435 
      else:
13436 
        iprot.skip(ftype)
13437 
      iprot.readFieldEnd()
13438 
    iprot.readStructEnd()
13439 
 
13440 
  def write(self, oprot):
13441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13443 
      return
4910 phani.kuma 13444 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13445 
    if self.ex is not None:
13446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13447 
      self.ex.write(oprot)
13448 
      oprot.writeFieldEnd()
13449 
    oprot.writeFieldStop()
13450 
    oprot.writeStructEnd()
13451 
 
13452 
  def validate(self):
13453 
    return
13454 
 
13455 
 
13456 
  def __repr__(self):
13457 
    L = ['%s=%r' % (key, value)
13458 
      for key, value in self.__dict__.iteritems()]
13459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13460 
 
13461 
  def __eq__(self, other):
13462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13463 
 
13464 
  def __ne__(self, other):
13465 
    return not (self == other)
13466 
 
13467 
class getOrdersNotLocalConnected_args:
13468 
  """
13469 
  Attributes:
13470 
   - providerId
13471 
  """
13472 
 
13473 
  thrift_spec = (
13474 
    None, # 0
13475 
    (1, TType.I64, 'providerId', None, None, ), # 1
13476 
  )
13477 
 
13478 
  def __init__(self, providerId=None,):
13479 
    self.providerId = providerId
13480 
 
13481 
  def read(self, iprot):
13482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13484 
      return
13485 
    iprot.readStructBegin()
13486 
    while True:
13487 
      (fname, ftype, fid) = iprot.readFieldBegin()
13488 
      if ftype == TType.STOP:
13489 
        break
13490 
      if fid == 1:
13491 
        if ftype == TType.I64:
13492 
          self.providerId = iprot.readI64();
13493 
        else:
13494 
          iprot.skip(ftype)
13495 
      else:
13496 
        iprot.skip(ftype)
13497 
      iprot.readFieldEnd()
13498 
    iprot.readStructEnd()
13499 
 
13500 
  def write(self, oprot):
13501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13503 
      return
13504 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13505 
    if self.providerId is not None:
13506 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13507 
      oprot.writeI64(self.providerId)
13508 
      oprot.writeFieldEnd()
13509 
    oprot.writeFieldStop()
13510 
    oprot.writeStructEnd()
13511 
 
13512 
  def validate(self):
13513 
    return
13514 
 
13515 
 
13516 
  def __repr__(self):
13517 
    L = ['%s=%r' % (key, value)
13518 
      for key, value in self.__dict__.iteritems()]
13519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13520 
 
13521 
  def __eq__(self, other):
13522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13523 
 
13524 
  def __ne__(self, other):
13525 
    return not (self == other)
13526 
 
13527 
class getOrdersNotLocalConnected_result:
13528 
  """
13529 
  Attributes:
13530 
   - success
13531 
  """
13532 
 
13533 
  thrift_spec = (
13534 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13535 
  )
13536 
 
13537 
  def __init__(self, success=None,):
13538 
    self.success = success
13539 
 
13540 
  def read(self, iprot):
13541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13543 
      return
13544 
    iprot.readStructBegin()
13545 
    while True:
13546 
      (fname, ftype, fid) = iprot.readFieldBegin()
13547 
      if ftype == TType.STOP:
13548 
        break
13549 
      if fid == 0:
13550 
        if ftype == TType.LIST:
13551 
          self.success = []
5411 rajveer 13552 
          (_etype314, _size311) = iprot.readListBegin()
13553 
          for _i315 in xrange(_size311):
13554 
            _elem316 = Order()
13555 
            _elem316.read(iprot)
13556 
            self.success.append(_elem316)
4910 phani.kuma 13557 
          iprot.readListEnd()
13558 
        else:
13559 
          iprot.skip(ftype)
13560 
      else:
13561 
        iprot.skip(ftype)
13562 
      iprot.readFieldEnd()
13563 
    iprot.readStructEnd()
13564 
 
13565 
  def write(self, oprot):
13566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13568 
      return
13569 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13570 
    if self.success is not None:
13571 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13572 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13573 
      for iter317 in self.success:
13574 
        iter317.write(oprot)
4581 phani.kuma 13575 
      oprot.writeListEnd()
13576 
      oprot.writeFieldEnd()
4910 phani.kuma 13577 
    oprot.writeFieldStop()
13578 
    oprot.writeStructEnd()
13579 
 
13580 
  def validate(self):
13581 
    return
13582 
 
13583 
 
13584 
  def __repr__(self):
13585 
    L = ['%s=%r' % (key, value)
13586 
      for key, value in self.__dict__.iteritems()]
13587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13588 
 
13589 
  def __eq__(self, other):
13590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13591 
 
13592 
  def __ne__(self, other):
13593 
    return not (self == other)
13594 
 
13595 
class markOrdersAsDestinationCityReached_args:
13596 
  """
13597 
  Attributes:
13598 
   - providerId
13599 
   - destination_city_reached_orders
13600 
  """
13601 
 
13602 
  thrift_spec = (
13603 
    None, # 0
13604 
    (1, TType.I64, 'providerId', None, None, ), # 1
13605 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13606 
  )
13607 
 
13608 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13609 
    self.providerId = providerId
13610 
    self.destination_city_reached_orders = destination_city_reached_orders
13611 
 
13612 
  def read(self, iprot):
13613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13615 
      return
13616 
    iprot.readStructBegin()
13617 
    while True:
13618 
      (fname, ftype, fid) = iprot.readFieldBegin()
13619 
      if ftype == TType.STOP:
13620 
        break
13621 
      if fid == 1:
13622 
        if ftype == TType.I64:
13623 
          self.providerId = iprot.readI64();
13624 
        else:
13625 
          iprot.skip(ftype)
13626 
      elif fid == 2:
13627 
        if ftype == TType.MAP:
13628 
          self.destination_city_reached_orders = {}
5411 rajveer 13629 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
13630 
          for _i322 in xrange(_size318):
13631 
            _key323 = iprot.readString();
13632 
            _val324 = iprot.readString();
13633 
            self.destination_city_reached_orders[_key323] = _val324
4910 phani.kuma 13634 
          iprot.readMapEnd()
13635 
        else:
13636 
          iprot.skip(ftype)
13637 
      else:
13638 
        iprot.skip(ftype)
13639 
      iprot.readFieldEnd()
13640 
    iprot.readStructEnd()
13641 
 
13642 
  def write(self, oprot):
13643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13645 
      return
13646 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13647 
    if self.providerId is not None:
13648 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13649 
      oprot.writeI64(self.providerId)
13650 
      oprot.writeFieldEnd()
13651 
    if self.destination_city_reached_orders is not None:
13652 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13653 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5411 rajveer 13654 
      for kiter325,viter326 in self.destination_city_reached_orders.items():
13655 
        oprot.writeString(kiter325)
13656 
        oprot.writeString(viter326)
4910 phani.kuma 13657 
      oprot.writeMapEnd()
13658 
      oprot.writeFieldEnd()
13659 
    oprot.writeFieldStop()
13660 
    oprot.writeStructEnd()
13661 
 
13662 
  def validate(self):
13663 
    return
13664 
 
13665 
 
13666 
  def __repr__(self):
13667 
    L = ['%s=%r' % (key, value)
13668 
      for key, value in self.__dict__.iteritems()]
13669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13670 
 
13671 
  def __eq__(self, other):
13672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13673 
 
13674 
  def __ne__(self, other):
13675 
    return not (self == other)
13676 
 
13677 
class markOrdersAsDestinationCityReached_result:
13678 
  """
13679 
  Attributes:
13680 
   - ex
13681 
  """
13682 
 
13683 
  thrift_spec = (
13684 
    None, # 0
13685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13686 
  )
13687 
 
13688 
  def __init__(self, ex=None,):
13689 
    self.ex = ex
13690 
 
13691 
  def read(self, iprot):
13692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13694 
      return
13695 
    iprot.readStructBegin()
13696 
    while True:
13697 
      (fname, ftype, fid) = iprot.readFieldBegin()
13698 
      if ftype == TType.STOP:
13699 
        break
13700 
      if fid == 1:
13701 
        if ftype == TType.STRUCT:
13702 
          self.ex = TransactionServiceException()
13703 
          self.ex.read(iprot)
13704 
        else:
13705 
          iprot.skip(ftype)
13706 
      else:
13707 
        iprot.skip(ftype)
13708 
      iprot.readFieldEnd()
13709 
    iprot.readStructEnd()
13710 
 
13711 
  def write(self, oprot):
13712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13714 
      return
13715 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13716 
    if self.ex is not None:
3064 chandransh 13717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13718 
      self.ex.write(oprot)
1627 ankur.sing 13719 
      oprot.writeFieldEnd()
13720 
    oprot.writeFieldStop()
13721 
    oprot.writeStructEnd()
13722 
 
3431 rajveer 13723 
  def validate(self):
13724 
    return
13725 
 
13726 
 
1627 ankur.sing 13727 
  def __repr__(self):
13728 
    L = ['%s=%r' % (key, value)
13729 
      for key, value in self.__dict__.iteritems()]
13730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13731 
 
13732 
  def __eq__(self, other):
13733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13734 
 
13735 
  def __ne__(self, other):
13736 
    return not (self == other)
13737 
 
4910 phani.kuma 13738 
class markOrdersAsFirstDeliveryAttempted_args:
13739 
  """
13740 
  Attributes:
13741 
   - providerId
13742 
   - first_atdl_orders
13743 
  """
13744 
 
13745 
  thrift_spec = (
13746 
    None, # 0
13747 
    (1, TType.I64, 'providerId', None, None, ), # 1
13748 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13749 
  )
13750 
 
13751 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13752 
    self.providerId = providerId
13753 
    self.first_atdl_orders = first_atdl_orders
13754 
 
13755 
  def read(self, iprot):
13756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13758 
      return
13759 
    iprot.readStructBegin()
13760 
    while True:
13761 
      (fname, ftype, fid) = iprot.readFieldBegin()
13762 
      if ftype == TType.STOP:
13763 
        break
13764 
      if fid == 1:
13765 
        if ftype == TType.I64:
13766 
          self.providerId = iprot.readI64();
13767 
        else:
13768 
          iprot.skip(ftype)
13769 
      elif fid == 2:
13770 
        if ftype == TType.MAP:
13771 
          self.first_atdl_orders = {}
5411 rajveer 13772 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
13773 
          for _i331 in xrange(_size327):
13774 
            _key332 = iprot.readString();
13775 
            _val333 = iprot.readString();
13776 
            self.first_atdl_orders[_key332] = _val333
4910 phani.kuma 13777 
          iprot.readMapEnd()
13778 
        else:
13779 
          iprot.skip(ftype)
13780 
      else:
13781 
        iprot.skip(ftype)
13782 
      iprot.readFieldEnd()
13783 
    iprot.readStructEnd()
13784 
 
13785 
  def write(self, oprot):
13786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13788 
      return
13789 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13790 
    if self.providerId is not None:
13791 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13792 
      oprot.writeI64(self.providerId)
13793 
      oprot.writeFieldEnd()
13794 
    if self.first_atdl_orders is not None:
13795 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13796 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5411 rajveer 13797 
      for kiter334,viter335 in self.first_atdl_orders.items():
13798 
        oprot.writeString(kiter334)
13799 
        oprot.writeString(viter335)
4910 phani.kuma 13800 
      oprot.writeMapEnd()
13801 
      oprot.writeFieldEnd()
13802 
    oprot.writeFieldStop()
13803 
    oprot.writeStructEnd()
13804 
 
13805 
  def validate(self):
13806 
    return
13807 
 
13808 
 
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 markOrdersAsFirstDeliveryAttempted_result:
13821 
  """
13822 
  Attributes:
13823 
   - ex
13824 
  """
13825 
 
13826 
  thrift_spec = (
13827 
    None, # 0
13828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13829 
  )
13830 
 
13831 
  def __init__(self, ex=None,):
13832 
    self.ex = ex
13833 
 
13834 
  def read(self, iprot):
13835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13837 
      return
13838 
    iprot.readStructBegin()
13839 
    while True:
13840 
      (fname, ftype, fid) = iprot.readFieldBegin()
13841 
      if ftype == TType.STOP:
13842 
        break
13843 
      if fid == 1:
13844 
        if ftype == TType.STRUCT:
13845 
          self.ex = TransactionServiceException()
13846 
          self.ex.read(iprot)
13847 
        else:
13848 
          iprot.skip(ftype)
13849 
      else:
13850 
        iprot.skip(ftype)
13851 
      iprot.readFieldEnd()
13852 
    iprot.readStructEnd()
13853 
 
13854 
  def write(self, oprot):
13855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13857 
      return
13858 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13859 
    if self.ex is not None:
13860 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13861 
      self.ex.write(oprot)
13862 
      oprot.writeFieldEnd()
13863 
    oprot.writeFieldStop()
13864 
    oprot.writeStructEnd()
13865 
 
13866 
  def validate(self):
13867 
    return
13868 
 
13869 
 
13870 
  def __repr__(self):
13871 
    L = ['%s=%r' % (key, value)
13872 
      for key, value in self.__dict__.iteritems()]
13873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13874 
 
13875 
  def __eq__(self, other):
13876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13877 
 
13878 
  def __ne__(self, other):
13879 
    return not (self == other)
13880 
 
3064 chandransh 13881 
class getUndeliveredOrders_args:
1886 ankur.sing 13882 
  """
13883 
  Attributes:
3064 chandransh 13884 
   - providerId
13885 
   - warehouseId
1886 ankur.sing 13886 
  """
1627 ankur.sing 13887 
 
1886 ankur.sing 13888 
  thrift_spec = (
13889 
    None, # 0
3064 chandransh 13890 
    (1, TType.I64, 'providerId', None, None, ), # 1
13891 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13892 
  )
13893 
 
3064 chandransh 13894 
  def __init__(self, providerId=None, warehouseId=None,):
13895 
    self.providerId = providerId
13896 
    self.warehouseId = warehouseId
1886 ankur.sing 13897 
 
13898 
  def read(self, iprot):
13899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13901 
      return
13902 
    iprot.readStructBegin()
13903 
    while True:
13904 
      (fname, ftype, fid) = iprot.readFieldBegin()
13905 
      if ftype == TType.STOP:
13906 
        break
13907 
      if fid == 1:
13908 
        if ftype == TType.I64:
3064 chandransh 13909 
          self.providerId = iprot.readI64();
1886 ankur.sing 13910 
        else:
13911 
          iprot.skip(ftype)
3064 chandransh 13912 
      elif fid == 2:
13913 
        if ftype == TType.I64:
13914 
          self.warehouseId = iprot.readI64();
13915 
        else:
13916 
          iprot.skip(ftype)
1886 ankur.sing 13917 
      else:
13918 
        iprot.skip(ftype)
13919 
      iprot.readFieldEnd()
13920 
    iprot.readStructEnd()
13921 
 
13922 
  def write(self, oprot):
13923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13925 
      return
3064 chandransh 13926 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13927 
    if self.providerId is not None:
3064 chandransh 13928 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13929 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13930 
      oprot.writeFieldEnd()
3431 rajveer 13931 
    if self.warehouseId is not None:
3064 chandransh 13932 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13933 
      oprot.writeI64(self.warehouseId)
13934 
      oprot.writeFieldEnd()
1886 ankur.sing 13935 
    oprot.writeFieldStop()
13936 
    oprot.writeStructEnd()
13937 
 
3431 rajveer 13938 
  def validate(self):
13939 
    return
13940 
 
13941 
 
1886 ankur.sing 13942 
  def __repr__(self):
13943 
    L = ['%s=%r' % (key, value)
13944 
      for key, value in self.__dict__.iteritems()]
13945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13946 
 
13947 
  def __eq__(self, other):
13948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13949 
 
13950 
  def __ne__(self, other):
13951 
    return not (self == other)
13952 
 
3064 chandransh 13953 
class getUndeliveredOrders_result:
1886 ankur.sing 13954 
  """
13955 
  Attributes:
13956 
   - success
13957 
  """
13958 
 
13959 
  thrift_spec = (
13960 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13961 
  )
13962 
 
13963 
  def __init__(self, success=None,):
13964 
    self.success = success
13965 
 
13966 
  def read(self, iprot):
13967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13969 
      return
13970 
    iprot.readStructBegin()
13971 
    while True:
13972 
      (fname, ftype, fid) = iprot.readFieldBegin()
13973 
      if ftype == TType.STOP:
13974 
        break
13975 
      if fid == 0:
13976 
        if ftype == TType.LIST:
13977 
          self.success = []
5411 rajveer 13978 
          (_etype339, _size336) = iprot.readListBegin()
13979 
          for _i340 in xrange(_size336):
13980 
            _elem341 = Order()
13981 
            _elem341.read(iprot)
13982 
            self.success.append(_elem341)
1886 ankur.sing 13983 
          iprot.readListEnd()
13984 
        else:
13985 
          iprot.skip(ftype)
13986 
      else:
13987 
        iprot.skip(ftype)
13988 
      iprot.readFieldEnd()
13989 
    iprot.readStructEnd()
13990 
 
13991 
  def write(self, oprot):
13992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13994 
      return
3064 chandransh 13995 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13996 
    if self.success is not None:
1886 ankur.sing 13997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13998 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13999 
      for iter342 in self.success:
14000 
        iter342.write(oprot)
1886 ankur.sing 14001 
      oprot.writeListEnd()
14002 
      oprot.writeFieldEnd()
14003 
    oprot.writeFieldStop()
14004 
    oprot.writeStructEnd()
14005 
 
3431 rajveer 14006 
  def validate(self):
14007 
    return
14008 
 
14009 
 
1886 ankur.sing 14010 
  def __repr__(self):
14011 
    L = ['%s=%r' % (key, value)
14012 
      for key, value in self.__dict__.iteritems()]
14013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14014 
 
14015 
  def __eq__(self, other):
14016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14017 
 
14018 
  def __ne__(self, other):
14019 
    return not (self == other)
14020 
 
4783 phani.kuma 14021 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14022 
 
14023 
  thrift_spec = (
14024 
  )
14025 
 
14026 
  def read(self, iprot):
14027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14029 
      return
14030 
    iprot.readStructBegin()
14031 
    while True:
14032 
      (fname, ftype, fid) = iprot.readFieldBegin()
14033 
      if ftype == TType.STOP:
14034 
        break
14035 
      else:
14036 
        iprot.skip(ftype)
14037 
      iprot.readFieldEnd()
14038 
    iprot.readStructEnd()
14039 
 
14040 
  def write(self, oprot):
14041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14043 
      return
14044 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14045 
    oprot.writeFieldStop()
14046 
    oprot.writeStructEnd()
14047 
 
14048 
  def validate(self):
14049 
    return
14050 
 
14051 
 
14052 
  def __repr__(self):
14053 
    L = ['%s=%r' % (key, value)
14054 
      for key, value in self.__dict__.iteritems()]
14055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14056 
 
14057 
  def __eq__(self, other):
14058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14059 
 
14060 
  def __ne__(self, other):
14061 
    return not (self == other)
14062 
 
14063 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14064 
  """
14065 
  Attributes:
14066 
   - success
14067 
  """
14068 
 
14069 
  thrift_spec = (
14070 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14071 
  )
14072 
 
14073 
  def __init__(self, success=None,):
14074 
    self.success = success
14075 
 
14076 
  def read(self, iprot):
14077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14079 
      return
14080 
    iprot.readStructBegin()
14081 
    while True:
14082 
      (fname, ftype, fid) = iprot.readFieldBegin()
14083 
      if ftype == TType.STOP:
14084 
        break
14085 
      if fid == 0:
14086 
        if ftype == TType.LIST:
14087 
          self.success = []
5411 rajveer 14088 
          (_etype346, _size343) = iprot.readListBegin()
14089 
          for _i347 in xrange(_size343):
14090 
            _elem348 = Order()
14091 
            _elem348.read(iprot)
14092 
            self.success.append(_elem348)
4783 phani.kuma 14093 
          iprot.readListEnd()
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      else:
14097 
        iprot.skip(ftype)
14098 
      iprot.readFieldEnd()
14099 
    iprot.readStructEnd()
14100 
 
14101 
  def write(self, oprot):
14102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14104 
      return
14105 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14106 
    if self.success is not None:
14107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14109 
      for iter349 in self.success:
14110 
        iter349.write(oprot)
4783 phani.kuma 14111 
      oprot.writeListEnd()
14112 
      oprot.writeFieldEnd()
14113 
    oprot.writeFieldStop()
14114 
    oprot.writeStructEnd()
14115 
 
14116 
  def validate(self):
14117 
    return
14118 
 
14119 
 
14120 
  def __repr__(self):
14121 
    L = ['%s=%r' % (key, value)
14122 
      for key, value in self.__dict__.iteritems()]
14123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14124 
 
14125 
  def __eq__(self, other):
14126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14127 
 
14128 
  def __ne__(self, other):
14129 
    return not (self == other)
14130 
 
2536 chandransh 14131 
class toggleDOAFlag_args:
14132 
  """
14133 
  Attributes:
14134 
   - orderId
14135 
  """
1886 ankur.sing 14136 
 
2536 chandransh 14137 
  thrift_spec = (
14138 
    None, # 0
14139 
    (1, TType.I64, 'orderId', None, None, ), # 1
14140 
  )
14141 
 
14142 
  def __init__(self, orderId=None,):
14143 
    self.orderId = orderId
14144 
 
14145 
  def read(self, iprot):
14146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14148 
      return
14149 
    iprot.readStructBegin()
14150 
    while True:
14151 
      (fname, ftype, fid) = iprot.readFieldBegin()
14152 
      if ftype == TType.STOP:
14153 
        break
14154 
      if fid == 1:
14155 
        if ftype == TType.I64:
14156 
          self.orderId = iprot.readI64();
14157 
        else:
14158 
          iprot.skip(ftype)
14159 
      else:
14160 
        iprot.skip(ftype)
14161 
      iprot.readFieldEnd()
14162 
    iprot.readStructEnd()
14163 
 
14164 
  def write(self, oprot):
14165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14167 
      return
14168 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14169 
    if self.orderId is not None:
2536 chandransh 14170 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14171 
      oprot.writeI64(self.orderId)
14172 
      oprot.writeFieldEnd()
14173 
    oprot.writeFieldStop()
14174 
    oprot.writeStructEnd()
14175 
 
3431 rajveer 14176 
  def validate(self):
14177 
    return
14178 
 
14179 
 
2536 chandransh 14180 
  def __repr__(self):
14181 
    L = ['%s=%r' % (key, value)
14182 
      for key, value in self.__dict__.iteritems()]
14183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14184 
 
14185 
  def __eq__(self, other):
14186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14187 
 
14188 
  def __ne__(self, other):
14189 
    return not (self == other)
14190 
 
14191 
class toggleDOAFlag_result:
14192 
  """
14193 
  Attributes:
14194 
   - success
14195 
   - ex
14196 
  """
14197 
 
14198 
  thrift_spec = (
14199 
    (0, TType.BOOL, 'success', None, None, ), # 0
14200 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14201 
  )
14202 
 
14203 
  def __init__(self, success=None, ex=None,):
14204 
    self.success = success
14205 
    self.ex = ex
14206 
 
14207 
  def read(self, iprot):
14208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14210 
      return
14211 
    iprot.readStructBegin()
14212 
    while True:
14213 
      (fname, ftype, fid) = iprot.readFieldBegin()
14214 
      if ftype == TType.STOP:
14215 
        break
14216 
      if fid == 0:
14217 
        if ftype == TType.BOOL:
14218 
          self.success = iprot.readBool();
14219 
        else:
14220 
          iprot.skip(ftype)
14221 
      elif fid == 1:
14222 
        if ftype == TType.STRUCT:
14223 
          self.ex = TransactionServiceException()
14224 
          self.ex.read(iprot)
14225 
        else:
14226 
          iprot.skip(ftype)
14227 
      else:
14228 
        iprot.skip(ftype)
14229 
      iprot.readFieldEnd()
14230 
    iprot.readStructEnd()
14231 
 
14232 
  def write(self, oprot):
14233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14235 
      return
14236 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14237 
    if self.success is not None:
2536 chandransh 14238 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14239 
      oprot.writeBool(self.success)
14240 
      oprot.writeFieldEnd()
3431 rajveer 14241 
    if self.ex is not None:
2536 chandransh 14242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14243 
      self.ex.write(oprot)
14244 
      oprot.writeFieldEnd()
14245 
    oprot.writeFieldStop()
14246 
    oprot.writeStructEnd()
14247 
 
3431 rajveer 14248 
  def validate(self):
14249 
    return
14250 
 
14251 
 
2536 chandransh 14252 
  def __repr__(self):
14253 
    L = ['%s=%r' % (key, value)
14254 
      for key, value in self.__dict__.iteritems()]
14255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14256 
 
14257 
  def __eq__(self, other):
14258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14259 
 
14260 
  def __ne__(self, other):
14261 
    return not (self == other)
14262 
 
4712 rajveer 14263 
class markOrderAsDelivered_args:
14264 
  """
14265 
  Attributes:
14266 
   - orderId
14267 
   - deliveryTimestamp
14268 
   - receiver
14269 
  """
14270 
 
14271 
  thrift_spec = None
14272 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14273 
    self.orderId = orderId
14274 
    self.deliveryTimestamp = deliveryTimestamp
14275 
    self.receiver = receiver
14276 
 
14277 
  def read(self, iprot):
14278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14280 
      return
14281 
    iprot.readStructBegin()
14282 
    while True:
14283 
      (fname, ftype, fid) = iprot.readFieldBegin()
14284 
      if ftype == TType.STOP:
14285 
        break
14286 
      if fid == 1:
14287 
        if ftype == TType.I64:
14288 
          self.orderId = iprot.readI64();
14289 
        else:
14290 
          iprot.skip(ftype)
14291 
      elif fid == 2:
14292 
        if ftype == TType.I64:
14293 
          self.deliveryTimestamp = iprot.readI64();
14294 
        else:
14295 
          iprot.skip(ftype)
14296 
      elif fid == -1:
14297 
        if ftype == TType.STRING:
14298 
          self.receiver = iprot.readString();
14299 
        else:
14300 
          iprot.skip(ftype)
14301 
      else:
14302 
        iprot.skip(ftype)
14303 
      iprot.readFieldEnd()
14304 
    iprot.readStructEnd()
14305 
 
14306 
  def write(self, oprot):
14307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14309 
      return
14310 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14311 
    if self.receiver is not None:
14312 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14313 
      oprot.writeString(self.receiver)
14314 
      oprot.writeFieldEnd()
14315 
    if self.orderId is not None:
14316 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14317 
      oprot.writeI64(self.orderId)
14318 
      oprot.writeFieldEnd()
14319 
    if self.deliveryTimestamp is not None:
14320 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14321 
      oprot.writeI64(self.deliveryTimestamp)
14322 
      oprot.writeFieldEnd()
14323 
    oprot.writeFieldStop()
14324 
    oprot.writeStructEnd()
14325 
 
14326 
  def validate(self):
14327 
    return
14328 
 
14329 
 
14330 
  def __repr__(self):
14331 
    L = ['%s=%r' % (key, value)
14332 
      for key, value in self.__dict__.iteritems()]
14333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14334 
 
14335 
  def __eq__(self, other):
14336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14337 
 
14338 
  def __ne__(self, other):
14339 
    return not (self == other)
14340 
 
14341 
class markOrderAsDelivered_result:
14342 
  """
14343 
  Attributes:
14344 
   - ex
14345 
  """
14346 
 
14347 
  thrift_spec = (
14348 
    None, # 0
14349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14350 
  )
14351 
 
14352 
  def __init__(self, ex=None,):
14353 
    self.ex = ex
14354 
 
14355 
  def read(self, iprot):
14356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14358 
      return
14359 
    iprot.readStructBegin()
14360 
    while True:
14361 
      (fname, ftype, fid) = iprot.readFieldBegin()
14362 
      if ftype == TType.STOP:
14363 
        break
14364 
      if fid == 1:
14365 
        if ftype == TType.STRUCT:
14366 
          self.ex = TransactionServiceException()
14367 
          self.ex.read(iprot)
14368 
        else:
14369 
          iprot.skip(ftype)
14370 
      else:
14371 
        iprot.skip(ftype)
14372 
      iprot.readFieldEnd()
14373 
    iprot.readStructEnd()
14374 
 
14375 
  def write(self, oprot):
14376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14378 
      return
14379 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14380 
    if self.ex is not None:
14381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14382 
      self.ex.write(oprot)
14383 
      oprot.writeFieldEnd()
14384 
    oprot.writeFieldStop()
14385 
    oprot.writeStructEnd()
14386 
 
14387 
  def validate(self):
14388 
    return
14389 
 
14390 
 
14391 
  def __repr__(self):
14392 
    L = ['%s=%r' % (key, value)
14393 
      for key, value in self.__dict__.iteritems()]
14394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14395 
 
14396 
  def __eq__(self, other):
14397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14398 
 
14399 
  def __ne__(self, other):
14400 
    return not (self == other)
14401 
 
4454 rajveer 14402 
class markOrderDoaRequestReceived_args:
14403 
  """
14404 
  Attributes:
14405 
   - orderId
14406 
  """
14407 
 
14408 
  thrift_spec = (
14409 
    None, # 0
14410 
    (1, TType.I64, 'orderId', None, None, ), # 1
14411 
  )
14412 
 
14413 
  def __init__(self, orderId=None,):
14414 
    self.orderId = orderId
14415 
 
14416 
  def read(self, iprot):
14417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14419 
      return
14420 
    iprot.readStructBegin()
14421 
    while True:
14422 
      (fname, ftype, fid) = iprot.readFieldBegin()
14423 
      if ftype == TType.STOP:
14424 
        break
14425 
      if fid == 1:
14426 
        if ftype == TType.I64:
14427 
          self.orderId = iprot.readI64();
14428 
        else:
14429 
          iprot.skip(ftype)
14430 
      else:
14431 
        iprot.skip(ftype)
14432 
      iprot.readFieldEnd()
14433 
    iprot.readStructEnd()
14434 
 
14435 
  def write(self, oprot):
14436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14438 
      return
14439 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14440 
    if self.orderId is not None:
14441 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14442 
      oprot.writeI64(self.orderId)
14443 
      oprot.writeFieldEnd()
14444 
    oprot.writeFieldStop()
14445 
    oprot.writeStructEnd()
14446 
 
14447 
  def validate(self):
14448 
    return
14449 
 
14450 
 
14451 
  def __repr__(self):
14452 
    L = ['%s=%r' % (key, value)
14453 
      for key, value in self.__dict__.iteritems()]
14454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14455 
 
14456 
  def __eq__(self, other):
14457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14458 
 
14459 
  def __ne__(self, other):
14460 
    return not (self == other)
14461 
 
14462 
class markOrderDoaRequestReceived_result:
14463 
  """
14464 
  Attributes:
14465 
   - success
14466 
   - ex
14467 
  """
14468 
 
14469 
  thrift_spec = (
14470 
    (0, TType.BOOL, 'success', None, None, ), # 0
14471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14472 
  )
14473 
 
14474 
  def __init__(self, success=None, ex=None,):
14475 
    self.success = success
14476 
    self.ex = ex
14477 
 
14478 
  def read(self, iprot):
14479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14481 
      return
14482 
    iprot.readStructBegin()
14483 
    while True:
14484 
      (fname, ftype, fid) = iprot.readFieldBegin()
14485 
      if ftype == TType.STOP:
14486 
        break
14487 
      if fid == 0:
14488 
        if ftype == TType.BOOL:
14489 
          self.success = iprot.readBool();
14490 
        else:
14491 
          iprot.skip(ftype)
14492 
      elif fid == 1:
14493 
        if ftype == TType.STRUCT:
14494 
          self.ex = TransactionServiceException()
14495 
          self.ex.read(iprot)
14496 
        else:
14497 
          iprot.skip(ftype)
14498 
      else:
14499 
        iprot.skip(ftype)
14500 
      iprot.readFieldEnd()
14501 
    iprot.readStructEnd()
14502 
 
14503 
  def write(self, oprot):
14504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14506 
      return
14507 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14508 
    if self.success is not None:
14509 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14510 
      oprot.writeBool(self.success)
14511 
      oprot.writeFieldEnd()
14512 
    if self.ex is not None:
14513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14514 
      self.ex.write(oprot)
14515 
      oprot.writeFieldEnd()
14516 
    oprot.writeFieldStop()
14517 
    oprot.writeStructEnd()
14518 
 
14519 
  def validate(self):
14520 
    return
14521 
 
14522 
 
14523 
  def __repr__(self):
14524 
    L = ['%s=%r' % (key, value)
14525 
      for key, value in self.__dict__.iteritems()]
14526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14527 
 
14528 
  def __eq__(self, other):
14529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14530 
 
14531 
  def __ne__(self, other):
14532 
    return not (self == other)
14533 
 
14534 
class markOrderDoaRequestAuthorized_args:
14535 
  """
14536 
  Attributes:
14537 
   - orderId
14538 
   - isAuthorized
14539 
  """
14540 
 
14541 
  thrift_spec = (
14542 
    None, # 0
14543 
    (1, TType.I64, 'orderId', None, None, ), # 1
14544 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14545 
  )
14546 
 
14547 
  def __init__(self, orderId=None, isAuthorized=None,):
14548 
    self.orderId = orderId
14549 
    self.isAuthorized = isAuthorized
14550 
 
14551 
  def read(self, iprot):
14552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14554 
      return
14555 
    iprot.readStructBegin()
14556 
    while True:
14557 
      (fname, ftype, fid) = iprot.readFieldBegin()
14558 
      if ftype == TType.STOP:
14559 
        break
14560 
      if fid == 1:
14561 
        if ftype == TType.I64:
14562 
          self.orderId = iprot.readI64();
14563 
        else:
14564 
          iprot.skip(ftype)
14565 
      elif fid == 2:
14566 
        if ftype == TType.BOOL:
14567 
          self.isAuthorized = iprot.readBool();
14568 
        else:
14569 
          iprot.skip(ftype)
14570 
      else:
14571 
        iprot.skip(ftype)
14572 
      iprot.readFieldEnd()
14573 
    iprot.readStructEnd()
14574 
 
14575 
  def write(self, oprot):
14576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14578 
      return
14579 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14580 
    if self.orderId is not None:
14581 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14582 
      oprot.writeI64(self.orderId)
14583 
      oprot.writeFieldEnd()
14584 
    if self.isAuthorized is not None:
14585 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14586 
      oprot.writeBool(self.isAuthorized)
14587 
      oprot.writeFieldEnd()
14588 
    oprot.writeFieldStop()
14589 
    oprot.writeStructEnd()
14590 
 
14591 
  def validate(self):
14592 
    return
14593 
 
14594 
 
14595 
  def __repr__(self):
14596 
    L = ['%s=%r' % (key, value)
14597 
      for key, value in self.__dict__.iteritems()]
14598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14599 
 
14600 
  def __eq__(self, other):
14601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14602 
 
14603 
  def __ne__(self, other):
14604 
    return not (self == other)
14605 
 
14606 
class markOrderDoaRequestAuthorized_result:
14607 
  """
14608 
  Attributes:
14609 
   - success
14610 
   - ex
14611 
  """
14612 
 
14613 
  thrift_spec = (
14614 
    (0, TType.BOOL, 'success', None, None, ), # 0
14615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14616 
  )
14617 
 
14618 
  def __init__(self, success=None, ex=None,):
14619 
    self.success = success
14620 
    self.ex = ex
14621 
 
14622 
  def read(self, iprot):
14623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14625 
      return
14626 
    iprot.readStructBegin()
14627 
    while True:
14628 
      (fname, ftype, fid) = iprot.readFieldBegin()
14629 
      if ftype == TType.STOP:
14630 
        break
14631 
      if fid == 0:
14632 
        if ftype == TType.BOOL:
14633 
          self.success = iprot.readBool();
14634 
        else:
14635 
          iprot.skip(ftype)
14636 
      elif fid == 1:
14637 
        if ftype == TType.STRUCT:
14638 
          self.ex = TransactionServiceException()
14639 
          self.ex.read(iprot)
14640 
        else:
14641 
          iprot.skip(ftype)
14642 
      else:
14643 
        iprot.skip(ftype)
14644 
      iprot.readFieldEnd()
14645 
    iprot.readStructEnd()
14646 
 
14647 
  def write(self, oprot):
14648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14650 
      return
14651 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14652 
    if self.success is not None:
14653 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14654 
      oprot.writeBool(self.success)
14655 
      oprot.writeFieldEnd()
14656 
    if self.ex is not None:
14657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14658 
      self.ex.write(oprot)
14659 
      oprot.writeFieldEnd()
14660 
    oprot.writeFieldStop()
14661 
    oprot.writeStructEnd()
14662 
 
14663 
  def validate(self):
14664 
    return
14665 
 
14666 
 
14667 
  def __repr__(self):
14668 
    L = ['%s=%r' % (key, value)
14669 
      for key, value in self.__dict__.iteritems()]
14670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14671 
 
14672 
  def __eq__(self, other):
14673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14674 
 
14675 
  def __ne__(self, other):
14676 
    return not (self == other)
14677 
 
4488 rajveer 14678 
class markOrderReturnRequestReceived_args:
14679 
  """
14680 
  Attributes:
14681 
   - orderId
14682 
  """
14683 
 
14684 
  thrift_spec = (
14685 
    None, # 0
14686 
    (1, TType.I64, 'orderId', None, None, ), # 1
14687 
  )
14688 
 
14689 
  def __init__(self, orderId=None,):
14690 
    self.orderId = orderId
14691 
 
14692 
  def read(self, iprot):
14693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14695 
      return
14696 
    iprot.readStructBegin()
14697 
    while True:
14698 
      (fname, ftype, fid) = iprot.readFieldBegin()
14699 
      if ftype == TType.STOP:
14700 
        break
14701 
      if fid == 1:
14702 
        if ftype == TType.I64:
14703 
          self.orderId = iprot.readI64();
14704 
        else:
14705 
          iprot.skip(ftype)
14706 
      else:
14707 
        iprot.skip(ftype)
14708 
      iprot.readFieldEnd()
14709 
    iprot.readStructEnd()
14710 
 
14711 
  def write(self, oprot):
14712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14714 
      return
14715 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14716 
    if self.orderId is not None:
14717 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14718 
      oprot.writeI64(self.orderId)
14719 
      oprot.writeFieldEnd()
14720 
    oprot.writeFieldStop()
14721 
    oprot.writeStructEnd()
14722 
 
14723 
  def validate(self):
14724 
    return
14725 
 
14726 
 
14727 
  def __repr__(self):
14728 
    L = ['%s=%r' % (key, value)
14729 
      for key, value in self.__dict__.iteritems()]
14730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14731 
 
14732 
  def __eq__(self, other):
14733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14734 
 
14735 
  def __ne__(self, other):
14736 
    return not (self == other)
14737 
 
14738 
class markOrderReturnRequestReceived_result:
14739 
  """
14740 
  Attributes:
14741 
   - success
14742 
   - ex
14743 
  """
14744 
 
14745 
  thrift_spec = (
14746 
    (0, TType.BOOL, 'success', None, None, ), # 0
14747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14748 
  )
14749 
 
14750 
  def __init__(self, success=None, ex=None,):
14751 
    self.success = success
14752 
    self.ex = ex
14753 
 
14754 
  def read(self, iprot):
14755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14757 
      return
14758 
    iprot.readStructBegin()
14759 
    while True:
14760 
      (fname, ftype, fid) = iprot.readFieldBegin()
14761 
      if ftype == TType.STOP:
14762 
        break
14763 
      if fid == 0:
14764 
        if ftype == TType.BOOL:
14765 
          self.success = iprot.readBool();
14766 
        else:
14767 
          iprot.skip(ftype)
14768 
      elif fid == 1:
14769 
        if ftype == TType.STRUCT:
14770 
          self.ex = TransactionServiceException()
14771 
          self.ex.read(iprot)
14772 
        else:
14773 
          iprot.skip(ftype)
14774 
      else:
14775 
        iprot.skip(ftype)
14776 
      iprot.readFieldEnd()
14777 
    iprot.readStructEnd()
14778 
 
14779 
  def write(self, oprot):
14780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14782 
      return
14783 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14784 
    if self.success is not None:
14785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14786 
      oprot.writeBool(self.success)
14787 
      oprot.writeFieldEnd()
14788 
    if self.ex is not None:
14789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14790 
      self.ex.write(oprot)
14791 
      oprot.writeFieldEnd()
14792 
    oprot.writeFieldStop()
14793 
    oprot.writeStructEnd()
14794 
 
14795 
  def validate(self):
14796 
    return
14797 
 
14798 
 
14799 
  def __repr__(self):
14800 
    L = ['%s=%r' % (key, value)
14801 
      for key, value in self.__dict__.iteritems()]
14802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14803 
 
14804 
  def __eq__(self, other):
14805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14806 
 
14807 
  def __ne__(self, other):
14808 
    return not (self == other)
14809 
 
14810 
class markOrderReturnRequestAuthorized_args:
14811 
  """
14812 
  Attributes:
14813 
   - orderId
14814 
   - isAuthorized
14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    None, # 0
14819 
    (1, TType.I64, 'orderId', None, None, ), # 1
14820 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14821 
  )
14822 
 
14823 
  def __init__(self, orderId=None, isAuthorized=None,):
14824 
    self.orderId = orderId
14825 
    self.isAuthorized = isAuthorized
14826 
 
14827 
  def read(self, iprot):
14828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14830 
      return
14831 
    iprot.readStructBegin()
14832 
    while True:
14833 
      (fname, ftype, fid) = iprot.readFieldBegin()
14834 
      if ftype == TType.STOP:
14835 
        break
14836 
      if fid == 1:
14837 
        if ftype == TType.I64:
14838 
          self.orderId = iprot.readI64();
14839 
        else:
14840 
          iprot.skip(ftype)
14841 
      elif fid == 2:
14842 
        if ftype == TType.BOOL:
14843 
          self.isAuthorized = iprot.readBool();
14844 
        else:
14845 
          iprot.skip(ftype)
14846 
      else:
14847 
        iprot.skip(ftype)
14848 
      iprot.readFieldEnd()
14849 
    iprot.readStructEnd()
14850 
 
14851 
  def write(self, oprot):
14852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14854 
      return
14855 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14856 
    if self.orderId is not None:
14857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14858 
      oprot.writeI64(self.orderId)
14859 
      oprot.writeFieldEnd()
14860 
    if self.isAuthorized is not None:
14861 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14862 
      oprot.writeBool(self.isAuthorized)
14863 
      oprot.writeFieldEnd()
14864 
    oprot.writeFieldStop()
14865 
    oprot.writeStructEnd()
14866 
 
14867 
  def validate(self):
14868 
    return
14869 
 
14870 
 
14871 
  def __repr__(self):
14872 
    L = ['%s=%r' % (key, value)
14873 
      for key, value in self.__dict__.iteritems()]
14874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14875 
 
14876 
  def __eq__(self, other):
14877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14878 
 
14879 
  def __ne__(self, other):
14880 
    return not (self == other)
14881 
 
14882 
class markOrderReturnRequestAuthorized_result:
14883 
  """
14884 
  Attributes:
14885 
   - success
14886 
   - ex
14887 
  """
14888 
 
14889 
  thrift_spec = (
14890 
    (0, TType.BOOL, 'success', None, None, ), # 0
14891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14892 
  )
14893 
 
14894 
  def __init__(self, success=None, ex=None,):
14895 
    self.success = success
14896 
    self.ex = ex
14897 
 
14898 
  def read(self, iprot):
14899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14901 
      return
14902 
    iprot.readStructBegin()
14903 
    while True:
14904 
      (fname, ftype, fid) = iprot.readFieldBegin()
14905 
      if ftype == TType.STOP:
14906 
        break
14907 
      if fid == 0:
14908 
        if ftype == TType.BOOL:
14909 
          self.success = iprot.readBool();
14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      elif fid == 1:
14913 
        if ftype == TType.STRUCT:
14914 
          self.ex = TransactionServiceException()
14915 
          self.ex.read(iprot)
14916 
        else:
14917 
          iprot.skip(ftype)
14918 
      else:
14919 
        iprot.skip(ftype)
14920 
      iprot.readFieldEnd()
14921 
    iprot.readStructEnd()
14922 
 
14923 
  def write(self, oprot):
14924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14926 
      return
14927 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14928 
    if self.success is not None:
14929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14930 
      oprot.writeBool(self.success)
14931 
      oprot.writeFieldEnd()
14932 
    if self.ex is not None:
14933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14934 
      self.ex.write(oprot)
14935 
      oprot.writeFieldEnd()
14936 
    oprot.writeFieldStop()
14937 
    oprot.writeStructEnd()
14938 
 
14939 
  def validate(self):
14940 
    return
14941 
 
14942 
 
14943 
  def __repr__(self):
14944 
    L = ['%s=%r' % (key, value)
14945 
      for key, value in self.__dict__.iteritems()]
14946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14947 
 
14948 
  def __eq__(self, other):
14949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14950 
 
14951 
  def __ne__(self, other):
14952 
    return not (self == other)
14953 
 
2536 chandransh 14954 
class requestPickupNumber_args:
14955 
  """
14956 
  Attributes:
14957 
   - orderId
4579 rajveer 14958 
   - providerId
2536 chandransh 14959 
  """
14960 
 
14961 
  thrift_spec = (
14962 
    None, # 0
14963 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14964 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14965 
  )
14966 
 
4579 rajveer 14967 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14968 
    self.orderId = orderId
4579 rajveer 14969 
    self.providerId = providerId
2536 chandransh 14970 
 
14971 
  def read(self, iprot):
14972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14974 
      return
14975 
    iprot.readStructBegin()
14976 
    while True:
14977 
      (fname, ftype, fid) = iprot.readFieldBegin()
14978 
      if ftype == TType.STOP:
14979 
        break
14980 
      if fid == 1:
14981 
        if ftype == TType.I64:
14982 
          self.orderId = iprot.readI64();
14983 
        else:
14984 
          iprot.skip(ftype)
4579 rajveer 14985 
      elif fid == 2:
14986 
        if ftype == TType.I64:
14987 
          self.providerId = iprot.readI64();
14988 
        else:
14989 
          iprot.skip(ftype)
2536 chandransh 14990 
      else:
14991 
        iprot.skip(ftype)
14992 
      iprot.readFieldEnd()
14993 
    iprot.readStructEnd()
14994 
 
14995 
  def write(self, oprot):
14996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14998 
      return
14999 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15000 
    if self.orderId is not None:
2536 chandransh 15001 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15002 
      oprot.writeI64(self.orderId)
15003 
      oprot.writeFieldEnd()
4579 rajveer 15004 
    if self.providerId is not None:
15005 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15006 
      oprot.writeI64(self.providerId)
15007 
      oprot.writeFieldEnd()
2536 chandransh 15008 
    oprot.writeFieldStop()
15009 
    oprot.writeStructEnd()
15010 
 
3431 rajveer 15011 
  def validate(self):
15012 
    return
15013 
 
15014 
 
2536 chandransh 15015 
  def __repr__(self):
15016 
    L = ['%s=%r' % (key, value)
15017 
      for key, value in self.__dict__.iteritems()]
15018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15019 
 
15020 
  def __eq__(self, other):
15021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15022 
 
15023 
  def __ne__(self, other):
15024 
    return not (self == other)
15025 
 
15026 
class requestPickupNumber_result:
15027 
  """
15028 
  Attributes:
15029 
   - success
15030 
   - ex
15031 
  """
15032 
 
15033 
  thrift_spec = (
15034 
    (0, TType.BOOL, 'success', None, None, ), # 0
15035 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15036 
  )
15037 
 
15038 
  def __init__(self, success=None, ex=None,):
15039 
    self.success = success
15040 
    self.ex = ex
15041 
 
15042 
  def read(self, iprot):
15043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15045 
      return
15046 
    iprot.readStructBegin()
15047 
    while True:
15048 
      (fname, ftype, fid) = iprot.readFieldBegin()
15049 
      if ftype == TType.STOP:
15050 
        break
15051 
      if fid == 0:
15052 
        if ftype == TType.BOOL:
15053 
          self.success = iprot.readBool();
15054 
        else:
15055 
          iprot.skip(ftype)
15056 
      elif fid == 1:
15057 
        if ftype == TType.STRUCT:
15058 
          self.ex = TransactionServiceException()
15059 
          self.ex.read(iprot)
15060 
        else:
15061 
          iprot.skip(ftype)
15062 
      else:
15063 
        iprot.skip(ftype)
15064 
      iprot.readFieldEnd()
15065 
    iprot.readStructEnd()
15066 
 
15067 
  def write(self, oprot):
15068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15070 
      return
15071 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15072 
    if self.success is not None:
2536 chandransh 15073 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15074 
      oprot.writeBool(self.success)
15075 
      oprot.writeFieldEnd()
3431 rajveer 15076 
    if self.ex is not None:
2536 chandransh 15077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15078 
      self.ex.write(oprot)
15079 
      oprot.writeFieldEnd()
15080 
    oprot.writeFieldStop()
15081 
    oprot.writeStructEnd()
15082 
 
3431 rajveer 15083 
  def validate(self):
15084 
    return
15085 
 
15086 
 
2536 chandransh 15087 
  def __repr__(self):
15088 
    L = ['%s=%r' % (key, value)
15089 
      for key, value in self.__dict__.iteritems()]
15090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15091 
 
15092 
  def __eq__(self, other):
15093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15094 
 
15095 
  def __ne__(self, other):
15096 
    return not (self == other)
15097 
 
15098 
class authorizePickup_args:
15099 
  """
15100 
  Attributes:
15101 
   - orderId
15102 
   - pickupNumber
4602 rajveer 15103 
   - providerId
2536 chandransh 15104 
  """
15105 
 
15106 
  thrift_spec = (
15107 
    None, # 0
15108 
    (1, TType.I64, 'orderId', None, None, ), # 1
15109 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15110 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15111 
  )
15112 
 
4602 rajveer 15113 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15114 
    self.orderId = orderId
15115 
    self.pickupNumber = pickupNumber
4602 rajveer 15116 
    self.providerId = providerId
2536 chandransh 15117 
 
15118 
  def read(self, iprot):
15119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15121 
      return
15122 
    iprot.readStructBegin()
15123 
    while True:
15124 
      (fname, ftype, fid) = iprot.readFieldBegin()
15125 
      if ftype == TType.STOP:
15126 
        break
15127 
      if fid == 1:
15128 
        if ftype == TType.I64:
15129 
          self.orderId = iprot.readI64();
15130 
        else:
15131 
          iprot.skip(ftype)
15132 
      elif fid == 2:
15133 
        if ftype == TType.STRING:
15134 
          self.pickupNumber = iprot.readString();
15135 
        else:
15136 
          iprot.skip(ftype)
4602 rajveer 15137 
      elif fid == 3:
15138 
        if ftype == TType.I64:
15139 
          self.providerId = iprot.readI64();
15140 
        else:
15141 
          iprot.skip(ftype)
2536 chandransh 15142 
      else:
15143 
        iprot.skip(ftype)
15144 
      iprot.readFieldEnd()
15145 
    iprot.readStructEnd()
15146 
 
15147 
  def write(self, oprot):
15148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15150 
      return
15151 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15152 
    if self.orderId is not None:
2536 chandransh 15153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15154 
      oprot.writeI64(self.orderId)
15155 
      oprot.writeFieldEnd()
3431 rajveer 15156 
    if self.pickupNumber is not None:
2536 chandransh 15157 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15158 
      oprot.writeString(self.pickupNumber)
15159 
      oprot.writeFieldEnd()
4602 rajveer 15160 
    if self.providerId is not None:
15161 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15162 
      oprot.writeI64(self.providerId)
15163 
      oprot.writeFieldEnd()
2536 chandransh 15164 
    oprot.writeFieldStop()
15165 
    oprot.writeStructEnd()
15166 
 
3431 rajveer 15167 
  def validate(self):
15168 
    return
15169 
 
15170 
 
2536 chandransh 15171 
  def __repr__(self):
15172 
    L = ['%s=%r' % (key, value)
15173 
      for key, value in self.__dict__.iteritems()]
15174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15175 
 
15176 
  def __eq__(self, other):
15177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15178 
 
15179 
  def __ne__(self, other):
15180 
    return not (self == other)
15181 
 
15182 
class authorizePickup_result:
15183 
  """
15184 
  Attributes:
15185 
   - success
15186 
   - ex
15187 
  """
15188 
 
15189 
  thrift_spec = (
15190 
    (0, TType.BOOL, 'success', None, None, ), # 0
15191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15192 
  )
15193 
 
15194 
  def __init__(self, success=None, ex=None,):
15195 
    self.success = success
15196 
    self.ex = ex
15197 
 
15198 
  def read(self, iprot):
15199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15201 
      return
15202 
    iprot.readStructBegin()
15203 
    while True:
15204 
      (fname, ftype, fid) = iprot.readFieldBegin()
15205 
      if ftype == TType.STOP:
15206 
        break
15207 
      if fid == 0:
15208 
        if ftype == TType.BOOL:
15209 
          self.success = iprot.readBool();
15210 
        else:
15211 
          iprot.skip(ftype)
15212 
      elif fid == 1:
15213 
        if ftype == TType.STRUCT:
15214 
          self.ex = TransactionServiceException()
15215 
          self.ex.read(iprot)
15216 
        else:
15217 
          iprot.skip(ftype)
15218 
      else:
15219 
        iprot.skip(ftype)
15220 
      iprot.readFieldEnd()
15221 
    iprot.readStructEnd()
15222 
 
15223 
  def write(self, oprot):
15224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15226 
      return
15227 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15228 
    if self.success is not None:
2536 chandransh 15229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15230 
      oprot.writeBool(self.success)
15231 
      oprot.writeFieldEnd()
3431 rajveer 15232 
    if self.ex is not None:
2536 chandransh 15233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15234 
      self.ex.write(oprot)
15235 
      oprot.writeFieldEnd()
15236 
    oprot.writeFieldStop()
15237 
    oprot.writeStructEnd()
15238 
 
3431 rajveer 15239 
  def validate(self):
15240 
    return
15241 
 
15242 
 
2536 chandransh 15243 
  def __repr__(self):
15244 
    L = ['%s=%r' % (key, value)
15245 
      for key, value in self.__dict__.iteritems()]
15246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15247 
 
15248 
  def __eq__(self, other):
15249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15250 
 
15251 
  def __ne__(self, other):
15252 
    return not (self == other)
15253 
 
2764 chandransh 15254 
class markDoasAsPickedUp_args:
15255 
  """
15256 
  Attributes:
15257 
   - providerId
15258 
   - pickupDetails
15259 
  """
15260 
 
15261 
  thrift_spec = (
15262 
    None, # 0
15263 
    (1, TType.I64, 'providerId', None, None, ), # 1
15264 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15265 
  )
15266 
 
15267 
  def __init__(self, providerId=None, pickupDetails=None,):
15268 
    self.providerId = providerId
15269 
    self.pickupDetails = pickupDetails
15270 
 
15271 
  def read(self, iprot):
15272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15274 
      return
15275 
    iprot.readStructBegin()
15276 
    while True:
15277 
      (fname, ftype, fid) = iprot.readFieldBegin()
15278 
      if ftype == TType.STOP:
15279 
        break
15280 
      if fid == 1:
15281 
        if ftype == TType.I64:
15282 
          self.providerId = iprot.readI64();
15283 
        else:
15284 
          iprot.skip(ftype)
15285 
      elif fid == 2:
15286 
        if ftype == TType.MAP:
15287 
          self.pickupDetails = {}
5411 rajveer 15288 
          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
15289 
          for _i354 in xrange(_size350):
15290 
            _key355 = iprot.readString();
15291 
            _val356 = iprot.readString();
15292 
            self.pickupDetails[_key355] = _val356
2764 chandransh 15293 
          iprot.readMapEnd()
15294 
        else:
15295 
          iprot.skip(ftype)
15296 
      else:
15297 
        iprot.skip(ftype)
15298 
      iprot.readFieldEnd()
15299 
    iprot.readStructEnd()
15300 
 
15301 
  def write(self, oprot):
15302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15304 
      return
15305 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15306 
    if self.providerId is not None:
2764 chandransh 15307 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15308 
      oprot.writeI64(self.providerId)
15309 
      oprot.writeFieldEnd()
3431 rajveer 15310 
    if self.pickupDetails is not None:
2764 chandransh 15311 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15312 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15313 
      for kiter357,viter358 in self.pickupDetails.items():
15314 
        oprot.writeString(kiter357)
15315 
        oprot.writeString(viter358)
2764 chandransh 15316 
      oprot.writeMapEnd()
15317 
      oprot.writeFieldEnd()
15318 
    oprot.writeFieldStop()
15319 
    oprot.writeStructEnd()
15320 
 
3431 rajveer 15321 
  def validate(self):
15322 
    return
15323 
 
15324 
 
2764 chandransh 15325 
  def __repr__(self):
15326 
    L = ['%s=%r' % (key, value)
15327 
      for key, value in self.__dict__.iteritems()]
15328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15329 
 
15330 
  def __eq__(self, other):
15331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15332 
 
15333 
  def __ne__(self, other):
15334 
    return not (self == other)
15335 
 
15336 
class markDoasAsPickedUp_result:
4910 phani.kuma 15337 
 
15338 
  thrift_spec = (
15339 
  )
15340 
 
15341 
  def read(self, iprot):
15342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15344 
      return
15345 
    iprot.readStructBegin()
15346 
    while True:
15347 
      (fname, ftype, fid) = iprot.readFieldBegin()
15348 
      if ftype == TType.STOP:
15349 
        break
15350 
      else:
15351 
        iprot.skip(ftype)
15352 
      iprot.readFieldEnd()
15353 
    iprot.readStructEnd()
15354 
 
15355 
  def write(self, oprot):
15356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15358 
      return
15359 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15360 
    oprot.writeFieldStop()
15361 
    oprot.writeStructEnd()
15362 
 
15363 
  def validate(self):
15364 
    return
15365 
 
15366 
 
15367 
  def __repr__(self):
15368 
    L = ['%s=%r' % (key, value)
15369 
      for key, value in self.__dict__.iteritems()]
15370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15371 
 
15372 
  def __eq__(self, other):
15373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15374 
 
15375 
  def __ne__(self, other):
15376 
    return not (self == other)
15377 
 
15378 
class getDoasNotPickedUp_args:
2764 chandransh 15379 
  """
15380 
  Attributes:
4910 phani.kuma 15381 
   - providerId
15382 
  """
15383 
 
15384 
  thrift_spec = (
15385 
    None, # 0
15386 
    (1, TType.I64, 'providerId', None, None, ), # 1
15387 
  )
15388 
 
15389 
  def __init__(self, providerId=None,):
15390 
    self.providerId = providerId
15391 
 
15392 
  def read(self, iprot):
15393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15395 
      return
15396 
    iprot.readStructBegin()
15397 
    while True:
15398 
      (fname, ftype, fid) = iprot.readFieldBegin()
15399 
      if ftype == TType.STOP:
15400 
        break
15401 
      if fid == 1:
15402 
        if ftype == TType.I64:
15403 
          self.providerId = iprot.readI64();
15404 
        else:
15405 
          iprot.skip(ftype)
15406 
      else:
15407 
        iprot.skip(ftype)
15408 
      iprot.readFieldEnd()
15409 
    iprot.readStructEnd()
15410 
 
15411 
  def write(self, oprot):
15412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15414 
      return
15415 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15416 
    if self.providerId is not None:
15417 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15418 
      oprot.writeI64(self.providerId)
15419 
      oprot.writeFieldEnd()
15420 
    oprot.writeFieldStop()
15421 
    oprot.writeStructEnd()
15422 
 
15423 
  def validate(self):
15424 
    return
15425 
 
15426 
 
15427 
  def __repr__(self):
15428 
    L = ['%s=%r' % (key, value)
15429 
      for key, value in self.__dict__.iteritems()]
15430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15431 
 
15432 
  def __eq__(self, other):
15433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15434 
 
15435 
  def __ne__(self, other):
15436 
    return not (self == other)
15437 
 
15438 
class getDoasNotPickedUp_result:
15439 
  """
15440 
  Attributes:
2764 chandransh 15441 
   - success
15442 
  """
15443 
 
15444 
  thrift_spec = (
15445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15446 
  )
15447 
 
15448 
  def __init__(self, success=None,):
15449 
    self.success = success
15450 
 
15451 
  def read(self, iprot):
15452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15454 
      return
15455 
    iprot.readStructBegin()
15456 
    while True:
15457 
      (fname, ftype, fid) = iprot.readFieldBegin()
15458 
      if ftype == TType.STOP:
15459 
        break
15460 
      if fid == 0:
15461 
        if ftype == TType.LIST:
15462 
          self.success = []
5411 rajveer 15463 
          (_etype362, _size359) = iprot.readListBegin()
15464 
          for _i363 in xrange(_size359):
15465 
            _elem364 = Order()
15466 
            _elem364.read(iprot)
15467 
            self.success.append(_elem364)
2764 chandransh 15468 
          iprot.readListEnd()
15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      else:
15472 
        iprot.skip(ftype)
15473 
      iprot.readFieldEnd()
15474 
    iprot.readStructEnd()
15475 
 
15476 
  def write(self, oprot):
15477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15479 
      return
4910 phani.kuma 15480 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15481 
    if self.success is not None:
2764 chandransh 15482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15484 
      for iter365 in self.success:
15485 
        iter365.write(oprot)
2764 chandransh 15486 
      oprot.writeListEnd()
15487 
      oprot.writeFieldEnd()
15488 
    oprot.writeFieldStop()
15489 
    oprot.writeStructEnd()
15490 
 
3431 rajveer 15491 
  def validate(self):
15492 
    return
15493 
 
15494 
 
2764 chandransh 15495 
  def __repr__(self):
15496 
    L = ['%s=%r' % (key, value)
15497 
      for key, value in self.__dict__.iteritems()]
15498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15499 
 
15500 
  def __eq__(self, other):
15501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15502 
 
15503 
  def __ne__(self, other):
15504 
    return not (self == other)
15505 
 
4741 phani.kuma 15506 
class markReturnOrdersAsPickedUp_args:
15507 
  """
15508 
  Attributes:
15509 
   - providerId
15510 
   - pickupDetails
15511 
  """
15512 
 
15513 
  thrift_spec = (
15514 
    None, # 0
15515 
    (1, TType.I64, 'providerId', None, None, ), # 1
15516 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15517 
  )
15518 
 
15519 
  def __init__(self, providerId=None, pickupDetails=None,):
15520 
    self.providerId = providerId
15521 
    self.pickupDetails = pickupDetails
15522 
 
15523 
  def read(self, iprot):
15524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15526 
      return
15527 
    iprot.readStructBegin()
15528 
    while True:
15529 
      (fname, ftype, fid) = iprot.readFieldBegin()
15530 
      if ftype == TType.STOP:
15531 
        break
15532 
      if fid == 1:
15533 
        if ftype == TType.I64:
15534 
          self.providerId = iprot.readI64();
15535 
        else:
15536 
          iprot.skip(ftype)
15537 
      elif fid == 2:
15538 
        if ftype == TType.MAP:
15539 
          self.pickupDetails = {}
5411 rajveer 15540 
          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
15541 
          for _i370 in xrange(_size366):
15542 
            _key371 = iprot.readString();
15543 
            _val372 = iprot.readString();
15544 
            self.pickupDetails[_key371] = _val372
4741 phani.kuma 15545 
          iprot.readMapEnd()
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15558 
    if self.providerId is not None:
15559 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15560 
      oprot.writeI64(self.providerId)
15561 
      oprot.writeFieldEnd()
15562 
    if self.pickupDetails is not None:
15563 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15564 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15565 
      for kiter373,viter374 in self.pickupDetails.items():
15566 
        oprot.writeString(kiter373)
15567 
        oprot.writeString(viter374)
4741 phani.kuma 15568 
      oprot.writeMapEnd()
15569 
      oprot.writeFieldEnd()
15570 
    oprot.writeFieldStop()
15571 
    oprot.writeStructEnd()
15572 
 
15573 
  def validate(self):
15574 
    return
15575 
 
15576 
 
15577 
  def __repr__(self):
15578 
    L = ['%s=%r' % (key, value)
15579 
      for key, value in self.__dict__.iteritems()]
15580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15581 
 
15582 
  def __eq__(self, other):
15583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15584 
 
15585 
  def __ne__(self, other):
15586 
    return not (self == other)
15587 
 
15588 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15589 
 
15590 
  thrift_spec = (
15591 
  )
15592 
 
15593 
  def read(self, iprot):
15594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15596 
      return
15597 
    iprot.readStructBegin()
15598 
    while True:
15599 
      (fname, ftype, fid) = iprot.readFieldBegin()
15600 
      if ftype == TType.STOP:
15601 
        break
15602 
      else:
15603 
        iprot.skip(ftype)
15604 
      iprot.readFieldEnd()
15605 
    iprot.readStructEnd()
15606 
 
15607 
  def write(self, oprot):
15608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15610 
      return
15611 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15612 
    oprot.writeFieldStop()
15613 
    oprot.writeStructEnd()
15614 
 
15615 
  def validate(self):
15616 
    return
15617 
 
15618 
 
15619 
  def __repr__(self):
15620 
    L = ['%s=%r' % (key, value)
15621 
      for key, value in self.__dict__.iteritems()]
15622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15623 
 
15624 
  def __eq__(self, other):
15625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15626 
 
15627 
  def __ne__(self, other):
15628 
    return not (self == other)
15629 
 
15630 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15631 
  """
15632 
  Attributes:
4910 phani.kuma 15633 
   - providerId
15634 
  """
15635 
 
15636 
  thrift_spec = (
15637 
    None, # 0
15638 
    (1, TType.I64, 'providerId', None, None, ), # 1
15639 
  )
15640 
 
15641 
  def __init__(self, providerId=None,):
15642 
    self.providerId = providerId
15643 
 
15644 
  def read(self, iprot):
15645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15647 
      return
15648 
    iprot.readStructBegin()
15649 
    while True:
15650 
      (fname, ftype, fid) = iprot.readFieldBegin()
15651 
      if ftype == TType.STOP:
15652 
        break
15653 
      if fid == 1:
15654 
        if ftype == TType.I64:
15655 
          self.providerId = iprot.readI64();
15656 
        else:
15657 
          iprot.skip(ftype)
15658 
      else:
15659 
        iprot.skip(ftype)
15660 
      iprot.readFieldEnd()
15661 
    iprot.readStructEnd()
15662 
 
15663 
  def write(self, oprot):
15664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15666 
      return
15667 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15668 
    if self.providerId is not None:
15669 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15670 
      oprot.writeI64(self.providerId)
15671 
      oprot.writeFieldEnd()
15672 
    oprot.writeFieldStop()
15673 
    oprot.writeStructEnd()
15674 
 
15675 
  def validate(self):
15676 
    return
15677 
 
15678 
 
15679 
  def __repr__(self):
15680 
    L = ['%s=%r' % (key, value)
15681 
      for key, value in self.__dict__.iteritems()]
15682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15683 
 
15684 
  def __eq__(self, other):
15685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15686 
 
15687 
  def __ne__(self, other):
15688 
    return not (self == other)
15689 
 
15690 
class getReturnOrdersNotPickedUp_result:
15691 
  """
15692 
  Attributes:
4741 phani.kuma 15693 
   - success
15694 
  """
15695 
 
15696 
  thrift_spec = (
15697 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15698 
  )
15699 
 
15700 
  def __init__(self, success=None,):
15701 
    self.success = success
15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 0:
15713 
        if ftype == TType.LIST:
15714 
          self.success = []
5411 rajveer 15715 
          (_etype378, _size375) = iprot.readListBegin()
15716 
          for _i379 in xrange(_size375):
15717 
            _elem380 = Order()
15718 
            _elem380.read(iprot)
15719 
            self.success.append(_elem380)
4741 phani.kuma 15720 
          iprot.readListEnd()
15721 
        else:
15722 
          iprot.skip(ftype)
15723 
      else:
15724 
        iprot.skip(ftype)
15725 
      iprot.readFieldEnd()
15726 
    iprot.readStructEnd()
15727 
 
15728 
  def write(self, oprot):
15729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15731 
      return
4910 phani.kuma 15732 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15733 
    if self.success is not None:
15734 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15735 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15736 
      for iter381 in self.success:
15737 
        iter381.write(oprot)
4741 phani.kuma 15738 
      oprot.writeListEnd()
15739 
      oprot.writeFieldEnd()
15740 
    oprot.writeFieldStop()
15741 
    oprot.writeStructEnd()
15742 
 
15743 
  def validate(self):
15744 
    return
15745 
 
15746 
 
15747 
  def __repr__(self):
15748 
    L = ['%s=%r' % (key, value)
15749 
      for key, value in self.__dict__.iteritems()]
15750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15751 
 
15752 
  def __eq__(self, other):
15753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15754 
 
15755 
  def __ne__(self, other):
15756 
    return not (self == other)
15757 
 
2616 chandransh 15758 
class receiveReturn_args:
2591 chandransh 15759 
  """
15760 
  Attributes:
15761 
   - orderId
4479 rajveer 15762 
   - receiveCondition
2591 chandransh 15763 
  """
2536 chandransh 15764 
 
2591 chandransh 15765 
  thrift_spec = (
15766 
    None, # 0
15767 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15768 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15769 
  )
15770 
 
4479 rajveer 15771 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15772 
    self.orderId = orderId
4479 rajveer 15773 
    self.receiveCondition = receiveCondition
2591 chandransh 15774 
 
15775 
  def read(self, iprot):
15776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15778 
      return
15779 
    iprot.readStructBegin()
15780 
    while True:
15781 
      (fname, ftype, fid) = iprot.readFieldBegin()
15782 
      if ftype == TType.STOP:
15783 
        break
15784 
      if fid == 1:
15785 
        if ftype == TType.I64:
15786 
          self.orderId = iprot.readI64();
15787 
        else:
15788 
          iprot.skip(ftype)
4479 rajveer 15789 
      elif fid == 2:
15790 
        if ftype == TType.I64:
15791 
          self.receiveCondition = iprot.readI64();
15792 
        else:
15793 
          iprot.skip(ftype)
2591 chandransh 15794 
      else:
15795 
        iprot.skip(ftype)
15796 
      iprot.readFieldEnd()
15797 
    iprot.readStructEnd()
15798 
 
15799 
  def write(self, oprot):
15800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15802 
      return
2616 chandransh 15803 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15804 
    if self.orderId is not None:
2591 chandransh 15805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15806 
      oprot.writeI64(self.orderId)
15807 
      oprot.writeFieldEnd()
4479 rajveer 15808 
    if self.receiveCondition is not None:
15809 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15810 
      oprot.writeI64(self.receiveCondition)
15811 
      oprot.writeFieldEnd()
2591 chandransh 15812 
    oprot.writeFieldStop()
15813 
    oprot.writeStructEnd()
15814 
 
3431 rajveer 15815 
  def validate(self):
15816 
    return
15817 
 
15818 
 
2591 chandransh 15819 
  def __repr__(self):
15820 
    L = ['%s=%r' % (key, value)
15821 
      for key, value in self.__dict__.iteritems()]
15822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15823 
 
15824 
  def __eq__(self, other):
15825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15826 
 
15827 
  def __ne__(self, other):
15828 
    return not (self == other)
15829 
 
2616 chandransh 15830 
class receiveReturn_result:
2591 chandransh 15831 
  """
15832 
  Attributes:
15833 
   - success
15834 
   - ex
15835 
  """
15836 
 
15837 
  thrift_spec = (
15838 
    (0, TType.BOOL, 'success', None, None, ), # 0
15839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15840 
  )
15841 
 
15842 
  def __init__(self, success=None, ex=None,):
15843 
    self.success = success
15844 
    self.ex = ex
15845 
 
15846 
  def read(self, iprot):
15847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15849 
      return
15850 
    iprot.readStructBegin()
15851 
    while True:
15852 
      (fname, ftype, fid) = iprot.readFieldBegin()
15853 
      if ftype == TType.STOP:
15854 
        break
15855 
      if fid == 0:
15856 
        if ftype == TType.BOOL:
15857 
          self.success = iprot.readBool();
15858 
        else:
15859 
          iprot.skip(ftype)
15860 
      elif fid == 1:
15861 
        if ftype == TType.STRUCT:
15862 
          self.ex = TransactionServiceException()
15863 
          self.ex.read(iprot)
15864 
        else:
15865 
          iprot.skip(ftype)
15866 
      else:
15867 
        iprot.skip(ftype)
15868 
      iprot.readFieldEnd()
15869 
    iprot.readStructEnd()
15870 
 
15871 
  def write(self, oprot):
15872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15874 
      return
2616 chandransh 15875 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15876 
    if self.success is not None:
2591 chandransh 15877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15878 
      oprot.writeBool(self.success)
15879 
      oprot.writeFieldEnd()
3431 rajveer 15880 
    if self.ex is not None:
2591 chandransh 15881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15882 
      self.ex.write(oprot)
15883 
      oprot.writeFieldEnd()
15884 
    oprot.writeFieldStop()
15885 
    oprot.writeStructEnd()
15886 
 
3431 rajveer 15887 
  def validate(self):
15888 
    return
15889 
 
15890 
 
2591 chandransh 15891 
  def __repr__(self):
15892 
    L = ['%s=%r' % (key, value)
15893 
      for key, value in self.__dict__.iteritems()]
15894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15895 
 
15896 
  def __eq__(self, other):
15897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15898 
 
15899 
  def __ne__(self, other):
15900 
    return not (self == other)
15901 
 
15902 
class validateDoa_args:
15903 
  """
15904 
  Attributes:
15905 
   - orderId
15906 
   - isValid
15907 
  """
15908 
 
15909 
  thrift_spec = (
15910 
    None, # 0
15911 
    (1, TType.I64, 'orderId', None, None, ), # 1
15912 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15913 
  )
15914 
 
15915 
  def __init__(self, orderId=None, isValid=None,):
15916 
    self.orderId = orderId
15917 
    self.isValid = isValid
15918 
 
15919 
  def read(self, iprot):
15920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15922 
      return
15923 
    iprot.readStructBegin()
15924 
    while True:
15925 
      (fname, ftype, fid) = iprot.readFieldBegin()
15926 
      if ftype == TType.STOP:
15927 
        break
15928 
      if fid == 1:
15929 
        if ftype == TType.I64:
15930 
          self.orderId = iprot.readI64();
15931 
        else:
15932 
          iprot.skip(ftype)
15933 
      elif fid == 2:
15934 
        if ftype == TType.BOOL:
15935 
          self.isValid = iprot.readBool();
15936 
        else:
15937 
          iprot.skip(ftype)
15938 
      else:
15939 
        iprot.skip(ftype)
15940 
      iprot.readFieldEnd()
15941 
    iprot.readStructEnd()
15942 
 
15943 
  def write(self, oprot):
15944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15946 
      return
15947 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15948 
    if self.orderId is not None:
2591 chandransh 15949 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15950 
      oprot.writeI64(self.orderId)
15951 
      oprot.writeFieldEnd()
3431 rajveer 15952 
    if self.isValid is not None:
2591 chandransh 15953 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15954 
      oprot.writeBool(self.isValid)
15955 
      oprot.writeFieldEnd()
15956 
    oprot.writeFieldStop()
15957 
    oprot.writeStructEnd()
15958 
 
3431 rajveer 15959 
  def validate(self):
15960 
    return
15961 
 
15962 
 
2591 chandransh 15963 
  def __repr__(self):
15964 
    L = ['%s=%r' % (key, value)
15965 
      for key, value in self.__dict__.iteritems()]
15966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15967 
 
15968 
  def __eq__(self, other):
15969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15970 
 
15971 
  def __ne__(self, other):
15972 
    return not (self == other)
15973 
 
15974 
class validateDoa_result:
15975 
  """
15976 
  Attributes:
15977 
   - success
15978 
   - ex
15979 
  """
15980 
 
15981 
  thrift_spec = (
15982 
    (0, TType.BOOL, 'success', None, None, ), # 0
15983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15984 
  )
15985 
 
15986 
  def __init__(self, success=None, ex=None,):
15987 
    self.success = success
15988 
    self.ex = ex
15989 
 
15990 
  def read(self, iprot):
15991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15993 
      return
15994 
    iprot.readStructBegin()
15995 
    while True:
15996 
      (fname, ftype, fid) = iprot.readFieldBegin()
15997 
      if ftype == TType.STOP:
15998 
        break
15999 
      if fid == 0:
16000 
        if ftype == TType.BOOL:
16001 
          self.success = iprot.readBool();
16002 
        else:
16003 
          iprot.skip(ftype)
16004 
      elif fid == 1:
16005 
        if ftype == TType.STRUCT:
16006 
          self.ex = TransactionServiceException()
16007 
          self.ex.read(iprot)
16008 
        else:
16009 
          iprot.skip(ftype)
16010 
      else:
16011 
        iprot.skip(ftype)
16012 
      iprot.readFieldEnd()
16013 
    iprot.readStructEnd()
16014 
 
16015 
  def write(self, oprot):
16016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16018 
      return
16019 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16020 
    if self.success is not None:
2591 chandransh 16021 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16022 
      oprot.writeBool(self.success)
16023 
      oprot.writeFieldEnd()
3431 rajveer 16024 
    if self.ex is not None:
2591 chandransh 16025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16026 
      self.ex.write(oprot)
16027 
      oprot.writeFieldEnd()
16028 
    oprot.writeFieldStop()
16029 
    oprot.writeStructEnd()
16030 
 
3431 rajveer 16031 
  def validate(self):
16032 
    return
16033 
 
16034 
 
2591 chandransh 16035 
  def __repr__(self):
16036 
    L = ['%s=%r' % (key, value)
16037 
      for key, value in self.__dict__.iteritems()]
16038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16039 
 
16040 
  def __eq__(self, other):
16041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16042 
 
16043 
  def __ne__(self, other):
16044 
    return not (self == other)
16045 
 
4495 rajveer 16046 
class validateReturnProduct_args:
16047 
  """
16048 
  Attributes:
16049 
   - orderId
16050 
   - isUsable
16051 
  """
16052 
 
16053 
  thrift_spec = (
16054 
    None, # 0
16055 
    (1, TType.I64, 'orderId', None, None, ), # 1
16056 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16057 
  )
16058 
 
16059 
  def __init__(self, orderId=None, isUsable=None,):
16060 
    self.orderId = orderId
16061 
    self.isUsable = isUsable
16062 
 
16063 
  def read(self, iprot):
16064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16066 
      return
16067 
    iprot.readStructBegin()
16068 
    while True:
16069 
      (fname, ftype, fid) = iprot.readFieldBegin()
16070 
      if ftype == TType.STOP:
16071 
        break
16072 
      if fid == 1:
16073 
        if ftype == TType.I64:
16074 
          self.orderId = iprot.readI64();
16075 
        else:
16076 
          iprot.skip(ftype)
16077 
      elif fid == 2:
16078 
        if ftype == TType.BOOL:
16079 
          self.isUsable = iprot.readBool();
16080 
        else:
16081 
          iprot.skip(ftype)
16082 
      else:
16083 
        iprot.skip(ftype)
16084 
      iprot.readFieldEnd()
16085 
    iprot.readStructEnd()
16086 
 
16087 
  def write(self, oprot):
16088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16090 
      return
16091 
    oprot.writeStructBegin('validateReturnProduct_args')
16092 
    if self.orderId is not None:
16093 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16094 
      oprot.writeI64(self.orderId)
16095 
      oprot.writeFieldEnd()
16096 
    if self.isUsable is not None:
16097 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16098 
      oprot.writeBool(self.isUsable)
16099 
      oprot.writeFieldEnd()
16100 
    oprot.writeFieldStop()
16101 
    oprot.writeStructEnd()
16102 
 
16103 
  def validate(self):
16104 
    return
16105 
 
16106 
 
16107 
  def __repr__(self):
16108 
    L = ['%s=%r' % (key, value)
16109 
      for key, value in self.__dict__.iteritems()]
16110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16111 
 
16112 
  def __eq__(self, other):
16113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16114 
 
16115 
  def __ne__(self, other):
16116 
    return not (self == other)
16117 
 
16118 
class validateReturnProduct_result:
16119 
  """
16120 
  Attributes:
16121 
   - success
16122 
   - ex
16123 
  """
16124 
 
16125 
  thrift_spec = (
16126 
    (0, TType.BOOL, 'success', None, None, ), # 0
16127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16128 
  )
16129 
 
16130 
  def __init__(self, success=None, ex=None,):
16131 
    self.success = success
16132 
    self.ex = ex
16133 
 
16134 
  def read(self, iprot):
16135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16137 
      return
16138 
    iprot.readStructBegin()
16139 
    while True:
16140 
      (fname, ftype, fid) = iprot.readFieldBegin()
16141 
      if ftype == TType.STOP:
16142 
        break
16143 
      if fid == 0:
16144 
        if ftype == TType.BOOL:
16145 
          self.success = iprot.readBool();
16146 
        else:
16147 
          iprot.skip(ftype)
16148 
      elif fid == 1:
16149 
        if ftype == TType.STRUCT:
16150 
          self.ex = TransactionServiceException()
16151 
          self.ex.read(iprot)
16152 
        else:
16153 
          iprot.skip(ftype)
16154 
      else:
16155 
        iprot.skip(ftype)
16156 
      iprot.readFieldEnd()
16157 
    iprot.readStructEnd()
16158 
 
16159 
  def write(self, oprot):
16160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16162 
      return
16163 
    oprot.writeStructBegin('validateReturnProduct_result')
16164 
    if self.success is not None:
16165 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16166 
      oprot.writeBool(self.success)
16167 
      oprot.writeFieldEnd()
16168 
    if self.ex is not None:
16169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16170 
      self.ex.write(oprot)
16171 
      oprot.writeFieldEnd()
16172 
    oprot.writeFieldStop()
16173 
    oprot.writeStructEnd()
16174 
 
16175 
  def validate(self):
16176 
    return
16177 
 
16178 
 
16179 
  def __repr__(self):
16180 
    L = ['%s=%r' % (key, value)
16181 
      for key, value in self.__dict__.iteritems()]
16182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16183 
 
16184 
  def __eq__(self, other):
16185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16186 
 
16187 
  def __ne__(self, other):
16188 
    return not (self == other)
16189 
 
2616 chandransh 16190 
class reshipOrder_args:
16191 
  """
16192 
  Attributes:
16193 
   - orderId
16194 
  """
2591 chandransh 16195 
 
2616 chandransh 16196 
  thrift_spec = (
16197 
    None, # 0
16198 
    (1, TType.I64, 'orderId', None, None, ), # 1
16199 
  )
16200 
 
16201 
  def __init__(self, orderId=None,):
16202 
    self.orderId = orderId
16203 
 
16204 
  def read(self, iprot):
16205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16207 
      return
16208 
    iprot.readStructBegin()
16209 
    while True:
16210 
      (fname, ftype, fid) = iprot.readFieldBegin()
16211 
      if ftype == TType.STOP:
16212 
        break
16213 
      if fid == 1:
16214 
        if ftype == TType.I64:
16215 
          self.orderId = iprot.readI64();
16216 
        else:
16217 
          iprot.skip(ftype)
16218 
      else:
16219 
        iprot.skip(ftype)
16220 
      iprot.readFieldEnd()
16221 
    iprot.readStructEnd()
16222 
 
16223 
  def write(self, oprot):
16224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16226 
      return
16227 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16228 
    if self.orderId is not None:
2616 chandransh 16229 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16230 
      oprot.writeI64(self.orderId)
16231 
      oprot.writeFieldEnd()
16232 
    oprot.writeFieldStop()
16233 
    oprot.writeStructEnd()
16234 
 
3431 rajveer 16235 
  def validate(self):
16236 
    return
16237 
 
16238 
 
2616 chandransh 16239 
  def __repr__(self):
16240 
    L = ['%s=%r' % (key, value)
16241 
      for key, value in self.__dict__.iteritems()]
16242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16243 
 
16244 
  def __eq__(self, other):
16245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16246 
 
16247 
  def __ne__(self, other):
16248 
    return not (self == other)
16249 
 
16250 
class reshipOrder_result:
16251 
  """
16252 
  Attributes:
16253 
   - success
16254 
   - ex
16255 
  """
16256 
 
16257 
  thrift_spec = (
16258 
    (0, TType.I64, 'success', None, None, ), # 0
16259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16260 
  )
16261 
 
16262 
  def __init__(self, success=None, ex=None,):
16263 
    self.success = success
16264 
    self.ex = ex
16265 
 
16266 
  def read(self, iprot):
16267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16269 
      return
16270 
    iprot.readStructBegin()
16271 
    while True:
16272 
      (fname, ftype, fid) = iprot.readFieldBegin()
16273 
      if ftype == TType.STOP:
16274 
        break
16275 
      if fid == 0:
16276 
        if ftype == TType.I64:
16277 
          self.success = iprot.readI64();
16278 
        else:
16279 
          iprot.skip(ftype)
16280 
      elif fid == 1:
16281 
        if ftype == TType.STRUCT:
16282 
          self.ex = TransactionServiceException()
16283 
          self.ex.read(iprot)
16284 
        else:
16285 
          iprot.skip(ftype)
16286 
      else:
16287 
        iprot.skip(ftype)
16288 
      iprot.readFieldEnd()
16289 
    iprot.readStructEnd()
16290 
 
16291 
  def write(self, oprot):
16292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16294 
      return
16295 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 16296 
    if self.success is not None:
2616 chandransh 16297 
      oprot.writeFieldBegin('success', TType.I64, 0)
16298 
      oprot.writeI64(self.success)
16299 
      oprot.writeFieldEnd()
3431 rajveer 16300 
    if self.ex is not None:
2616 chandransh 16301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16302 
      self.ex.write(oprot)
16303 
      oprot.writeFieldEnd()
16304 
    oprot.writeFieldStop()
16305 
    oprot.writeStructEnd()
16306 
 
3431 rajveer 16307 
  def validate(self):
16308 
    return
16309 
 
16310 
 
2616 chandransh 16311 
  def __repr__(self):
16312 
    L = ['%s=%r' % (key, value)
16313 
      for key, value in self.__dict__.iteritems()]
16314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16315 
 
16316 
  def __eq__(self, other):
16317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16318 
 
16319 
  def __ne__(self, other):
16320 
    return not (self == other)
16321 
 
16322 
class refundOrder_args:
16323 
  """
16324 
  Attributes:
16325 
   - orderId
3226 chandransh 16326 
   - refundedBy
16327 
   - reason
2616 chandransh 16328 
  """
16329 
 
16330 
  thrift_spec = (
16331 
    None, # 0
16332 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16333 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16334 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16335 
  )
16336 
 
3226 chandransh 16337 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16338 
    self.orderId = orderId
3226 chandransh 16339 
    self.refundedBy = refundedBy
16340 
    self.reason = reason
2616 chandransh 16341 
 
16342 
  def read(self, iprot):
16343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16345 
      return
16346 
    iprot.readStructBegin()
16347 
    while True:
16348 
      (fname, ftype, fid) = iprot.readFieldBegin()
16349 
      if ftype == TType.STOP:
16350 
        break
16351 
      if fid == 1:
16352 
        if ftype == TType.I64:
16353 
          self.orderId = iprot.readI64();
16354 
        else:
16355 
          iprot.skip(ftype)
3226 chandransh 16356 
      elif fid == 2:
16357 
        if ftype == TType.STRING:
16358 
          self.refundedBy = iprot.readString();
16359 
        else:
16360 
          iprot.skip(ftype)
16361 
      elif fid == 3:
16362 
        if ftype == TType.STRING:
16363 
          self.reason = iprot.readString();
16364 
        else:
16365 
          iprot.skip(ftype)
2616 chandransh 16366 
      else:
16367 
        iprot.skip(ftype)
16368 
      iprot.readFieldEnd()
16369 
    iprot.readStructEnd()
16370 
 
16371 
  def write(self, oprot):
16372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16374 
      return
16375 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16376 
    if self.orderId is not None:
2616 chandransh 16377 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16378 
      oprot.writeI64(self.orderId)
16379 
      oprot.writeFieldEnd()
3431 rajveer 16380 
    if self.refundedBy is not None:
3226 chandransh 16381 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16382 
      oprot.writeString(self.refundedBy)
16383 
      oprot.writeFieldEnd()
3431 rajveer 16384 
    if self.reason is not None:
3226 chandransh 16385 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16386 
      oprot.writeString(self.reason)
16387 
      oprot.writeFieldEnd()
2616 chandransh 16388 
    oprot.writeFieldStop()
16389 
    oprot.writeStructEnd()
16390 
 
3431 rajveer 16391 
  def validate(self):
16392 
    return
16393 
 
16394 
 
2616 chandransh 16395 
  def __repr__(self):
16396 
    L = ['%s=%r' % (key, value)
16397 
      for key, value in self.__dict__.iteritems()]
16398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16399 
 
16400 
  def __eq__(self, other):
16401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16402 
 
16403 
  def __ne__(self, other):
16404 
    return not (self == other)
16405 
 
16406 
class refundOrder_result:
16407 
  """
16408 
  Attributes:
16409 
   - success
16410 
   - ex
16411 
  """
16412 
 
16413 
  thrift_spec = (
16414 
    (0, TType.BOOL, 'success', None, None, ), # 0
16415 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16416 
  )
16417 
 
16418 
  def __init__(self, success=None, ex=None,):
16419 
    self.success = success
16420 
    self.ex = ex
16421 
 
16422 
  def read(self, iprot):
16423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16425 
      return
16426 
    iprot.readStructBegin()
16427 
    while True:
16428 
      (fname, ftype, fid) = iprot.readFieldBegin()
16429 
      if ftype == TType.STOP:
16430 
        break
16431 
      if fid == 0:
16432 
        if ftype == TType.BOOL:
16433 
          self.success = iprot.readBool();
16434 
        else:
16435 
          iprot.skip(ftype)
16436 
      elif fid == 1:
16437 
        if ftype == TType.STRUCT:
16438 
          self.ex = TransactionServiceException()
16439 
          self.ex.read(iprot)
16440 
        else:
16441 
          iprot.skip(ftype)
16442 
      else:
16443 
        iprot.skip(ftype)
16444 
      iprot.readFieldEnd()
16445 
    iprot.readStructEnd()
16446 
 
16447 
  def write(self, oprot):
16448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16450 
      return
16451 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16452 
    if self.success is not None:
2616 chandransh 16453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16454 
      oprot.writeBool(self.success)
16455 
      oprot.writeFieldEnd()
3431 rajveer 16456 
    if self.ex is not None:
2616 chandransh 16457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16458 
      self.ex.write(oprot)
16459 
      oprot.writeFieldEnd()
16460 
    oprot.writeFieldStop()
16461 
    oprot.writeStructEnd()
16462 
 
3431 rajveer 16463 
  def validate(self):
16464 
    return
16465 
 
16466 
 
2616 chandransh 16467 
  def __repr__(self):
16468 
    L = ['%s=%r' % (key, value)
16469 
      for key, value in self.__dict__.iteritems()]
16470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16471 
 
16472 
  def __eq__(self, other):
16473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16474 
 
16475 
  def __ne__(self, other):
16476 
    return not (self == other)
16477 
 
2690 chandransh 16478 
class getReturnOrders_args:
16479 
  """
16480 
  Attributes:
16481 
   - warehouseId
16482 
   - fromDate
16483 
   - toDate
16484 
  """
2616 chandransh 16485 
 
2690 chandransh 16486 
  thrift_spec = (
16487 
    None, # 0
16488 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16489 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16490 
    (3, TType.I64, 'toDate', None, None, ), # 3
16491 
  )
16492 
 
16493 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16494 
    self.warehouseId = warehouseId
16495 
    self.fromDate = fromDate
16496 
    self.toDate = toDate
16497 
 
16498 
  def read(self, iprot):
16499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16501 
      return
16502 
    iprot.readStructBegin()
16503 
    while True:
16504 
      (fname, ftype, fid) = iprot.readFieldBegin()
16505 
      if ftype == TType.STOP:
16506 
        break
16507 
      if fid == 1:
16508 
        if ftype == TType.I64:
16509 
          self.warehouseId = iprot.readI64();
16510 
        else:
16511 
          iprot.skip(ftype)
16512 
      elif fid == 2:
16513 
        if ftype == TType.I64:
16514 
          self.fromDate = iprot.readI64();
16515 
        else:
16516 
          iprot.skip(ftype)
16517 
      elif fid == 3:
16518 
        if ftype == TType.I64:
16519 
          self.toDate = iprot.readI64();
16520 
        else:
16521 
          iprot.skip(ftype)
16522 
      else:
16523 
        iprot.skip(ftype)
16524 
      iprot.readFieldEnd()
16525 
    iprot.readStructEnd()
16526 
 
16527 
  def write(self, oprot):
16528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16530 
      return
16531 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16532 
    if self.warehouseId is not None:
2690 chandransh 16533 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16534 
      oprot.writeI64(self.warehouseId)
16535 
      oprot.writeFieldEnd()
3431 rajveer 16536 
    if self.fromDate is not None:
2690 chandransh 16537 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16538 
      oprot.writeI64(self.fromDate)
16539 
      oprot.writeFieldEnd()
3431 rajveer 16540 
    if self.toDate is not None:
2690 chandransh 16541 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16542 
      oprot.writeI64(self.toDate)
16543 
      oprot.writeFieldEnd()
16544 
    oprot.writeFieldStop()
16545 
    oprot.writeStructEnd()
16546 
 
3431 rajveer 16547 
  def validate(self):
16548 
    return
16549 
 
16550 
 
2690 chandransh 16551 
  def __repr__(self):
16552 
    L = ['%s=%r' % (key, value)
16553 
      for key, value in self.__dict__.iteritems()]
16554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16555 
 
16556 
  def __eq__(self, other):
16557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16558 
 
16559 
  def __ne__(self, other):
16560 
    return not (self == other)
16561 
 
16562 
class getReturnOrders_result:
16563 
  """
16564 
  Attributes:
16565 
   - success
16566 
  """
16567 
 
16568 
  thrift_spec = (
16569 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16570 
  )
16571 
 
16572 
  def __init__(self, success=None,):
16573 
    self.success = success
16574 
 
16575 
  def read(self, iprot):
16576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16578 
      return
16579 
    iprot.readStructBegin()
16580 
    while True:
16581 
      (fname, ftype, fid) = iprot.readFieldBegin()
16582 
      if ftype == TType.STOP:
16583 
        break
16584 
      if fid == 0:
16585 
        if ftype == TType.LIST:
16586 
          self.success = []
5411 rajveer 16587 
          (_etype385, _size382) = iprot.readListBegin()
16588 
          for _i386 in xrange(_size382):
16589 
            _elem387 = ReturnOrder()
16590 
            _elem387.read(iprot)
16591 
            self.success.append(_elem387)
2690 chandransh 16592 
          iprot.readListEnd()
16593 
        else:
16594 
          iprot.skip(ftype)
16595 
      else:
16596 
        iprot.skip(ftype)
16597 
      iprot.readFieldEnd()
16598 
    iprot.readStructEnd()
16599 
 
16600 
  def write(self, oprot):
16601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16603 
      return
16604 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16605 
    if self.success is not None:
2690 chandransh 16606 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16607 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 16608 
      for iter388 in self.success:
16609 
        iter388.write(oprot)
2690 chandransh 16610 
      oprot.writeListEnd()
16611 
      oprot.writeFieldEnd()
16612 
    oprot.writeFieldStop()
16613 
    oprot.writeStructEnd()
16614 
 
3431 rajveer 16615 
  def validate(self):
16616 
    return
16617 
 
16618 
 
2690 chandransh 16619 
  def __repr__(self):
16620 
    L = ['%s=%r' % (key, value)
16621 
      for key, value in self.__dict__.iteritems()]
16622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16623 
 
16624 
  def __eq__(self, other):
16625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16626 
 
16627 
  def __ne__(self, other):
16628 
    return not (self == other)
16629 
 
5481 phani.kuma 16630 
class getAllReturnOrders_args:
16631 
  """
16632 
  Attributes:
16633 
   - onlyNotProcessed
16634 
   - fromDate
16635 
   - toDate
16636 
  """
16637 
 
16638 
  thrift_spec = (
16639 
    None, # 0
16640 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
16641 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16642 
    (3, TType.I64, 'toDate', None, None, ), # 3
16643 
  )
16644 
 
16645 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
16646 
    self.onlyNotProcessed = onlyNotProcessed
16647 
    self.fromDate = fromDate
16648 
    self.toDate = toDate
16649 
 
16650 
  def read(self, iprot):
16651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16653 
      return
16654 
    iprot.readStructBegin()
16655 
    while True:
16656 
      (fname, ftype, fid) = iprot.readFieldBegin()
16657 
      if ftype == TType.STOP:
16658 
        break
16659 
      if fid == 1:
16660 
        if ftype == TType.BOOL:
16661 
          self.onlyNotProcessed = iprot.readBool();
16662 
        else:
16663 
          iprot.skip(ftype)
16664 
      elif fid == 2:
16665 
        if ftype == TType.I64:
16666 
          self.fromDate = iprot.readI64();
16667 
        else:
16668 
          iprot.skip(ftype)
16669 
      elif fid == 3:
16670 
        if ftype == TType.I64:
16671 
          self.toDate = iprot.readI64();
16672 
        else:
16673 
          iprot.skip(ftype)
16674 
      else:
16675 
        iprot.skip(ftype)
16676 
      iprot.readFieldEnd()
16677 
    iprot.readStructEnd()
16678 
 
16679 
  def write(self, oprot):
16680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16682 
      return
16683 
    oprot.writeStructBegin('getAllReturnOrders_args')
16684 
    if self.onlyNotProcessed is not None:
16685 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
16686 
      oprot.writeBool(self.onlyNotProcessed)
16687 
      oprot.writeFieldEnd()
16688 
    if self.fromDate is not None:
16689 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16690 
      oprot.writeI64(self.fromDate)
16691 
      oprot.writeFieldEnd()
16692 
    if self.toDate is not None:
16693 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16694 
      oprot.writeI64(self.toDate)
16695 
      oprot.writeFieldEnd()
16696 
    oprot.writeFieldStop()
16697 
    oprot.writeStructEnd()
16698 
 
16699 
  def validate(self):
16700 
    return
16701 
 
16702 
 
16703 
  def __repr__(self):
16704 
    L = ['%s=%r' % (key, value)
16705 
      for key, value in self.__dict__.iteritems()]
16706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16707 
 
16708 
  def __eq__(self, other):
16709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16710 
 
16711 
  def __ne__(self, other):
16712 
    return not (self == other)
16713 
 
16714 
class getAllReturnOrders_result:
16715 
  """
16716 
  Attributes:
16717 
   - success
16718 
  """
16719 
 
16720 
  thrift_spec = (
16721 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16722 
  )
16723 
 
16724 
  def __init__(self, success=None,):
16725 
    self.success = success
16726 
 
16727 
  def read(self, iprot):
16728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16730 
      return
16731 
    iprot.readStructBegin()
16732 
    while True:
16733 
      (fname, ftype, fid) = iprot.readFieldBegin()
16734 
      if ftype == TType.STOP:
16735 
        break
16736 
      if fid == 0:
16737 
        if ftype == TType.LIST:
16738 
          self.success = []
16739 
          (_etype392, _size389) = iprot.readListBegin()
16740 
          for _i393 in xrange(_size389):
16741 
            _elem394 = ReturnOrder()
16742 
            _elem394.read(iprot)
16743 
            self.success.append(_elem394)
16744 
          iprot.readListEnd()
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      else:
16748 
        iprot.skip(ftype)
16749 
      iprot.readFieldEnd()
16750 
    iprot.readStructEnd()
16751 
 
16752 
  def write(self, oprot):
16753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16755 
      return
16756 
    oprot.writeStructBegin('getAllReturnOrders_result')
16757 
    if self.success is not None:
16758 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16759 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16760 
      for iter395 in self.success:
16761 
        iter395.write(oprot)
16762 
      oprot.writeListEnd()
16763 
      oprot.writeFieldEnd()
16764 
    oprot.writeFieldStop()
16765 
    oprot.writeStructEnd()
16766 
 
16767 
  def validate(self):
16768 
    return
16769 
 
16770 
 
16771 
  def __repr__(self):
16772 
    L = ['%s=%r' % (key, value)
16773 
      for key, value in self.__dict__.iteritems()]
16774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16775 
 
16776 
  def __eq__(self, other):
16777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16778 
 
16779 
  def __ne__(self, other):
16780 
    return not (self == other)
16781 
 
2700 chandransh 16782 
class getReturnOrder_args:
16783 
  """
16784 
  Attributes:
16785 
   - id
16786 
  """
16787 
 
16788 
  thrift_spec = (
16789 
    None, # 0
16790 
    (1, TType.I64, 'id', None, None, ), # 1
16791 
  )
16792 
 
16793 
  def __init__(self, id=None,):
16794 
    self.id = id
16795 
 
16796 
  def read(self, iprot):
16797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16799 
      return
16800 
    iprot.readStructBegin()
16801 
    while True:
16802 
      (fname, ftype, fid) = iprot.readFieldBegin()
16803 
      if ftype == TType.STOP:
16804 
        break
16805 
      if fid == 1:
16806 
        if ftype == TType.I64:
16807 
          self.id = iprot.readI64();
16808 
        else:
16809 
          iprot.skip(ftype)
16810 
      else:
16811 
        iprot.skip(ftype)
16812 
      iprot.readFieldEnd()
16813 
    iprot.readStructEnd()
16814 
 
16815 
  def write(self, oprot):
16816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16818 
      return
16819 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16820 
    if self.id is not None:
2700 chandransh 16821 
      oprot.writeFieldBegin('id', TType.I64, 1)
16822 
      oprot.writeI64(self.id)
16823 
      oprot.writeFieldEnd()
16824 
    oprot.writeFieldStop()
16825 
    oprot.writeStructEnd()
16826 
 
3431 rajveer 16827 
  def validate(self):
16828 
    return
16829 
 
16830 
 
2700 chandransh 16831 
  def __repr__(self):
16832 
    L = ['%s=%r' % (key, value)
16833 
      for key, value in self.__dict__.iteritems()]
16834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16835 
 
16836 
  def __eq__(self, other):
16837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16838 
 
16839 
  def __ne__(self, other):
16840 
    return not (self == other)
16841 
 
16842 
class getReturnOrder_result:
16843 
  """
16844 
  Attributes:
16845 
   - success
16846 
   - ex
16847 
  """
16848 
 
16849 
  thrift_spec = (
16850 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16852 
  )
16853 
 
16854 
  def __init__(self, success=None, ex=None,):
16855 
    self.success = success
16856 
    self.ex = ex
16857 
 
16858 
  def read(self, iprot):
16859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16861 
      return
16862 
    iprot.readStructBegin()
16863 
    while True:
16864 
      (fname, ftype, fid) = iprot.readFieldBegin()
16865 
      if ftype == TType.STOP:
16866 
        break
16867 
      if fid == 0:
16868 
        if ftype == TType.STRUCT:
16869 
          self.success = ReturnOrder()
16870 
          self.success.read(iprot)
16871 
        else:
16872 
          iprot.skip(ftype)
16873 
      elif fid == 1:
16874 
        if ftype == TType.STRUCT:
16875 
          self.ex = TransactionServiceException()
16876 
          self.ex.read(iprot)
16877 
        else:
16878 
          iprot.skip(ftype)
16879 
      else:
16880 
        iprot.skip(ftype)
16881 
      iprot.readFieldEnd()
16882 
    iprot.readStructEnd()
16883 
 
16884 
  def write(self, oprot):
16885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16887 
      return
16888 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16889 
    if self.success is not None:
2700 chandransh 16890 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16891 
      self.success.write(oprot)
16892 
      oprot.writeFieldEnd()
3431 rajveer 16893 
    if self.ex is not None:
2700 chandransh 16894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16895 
      self.ex.write(oprot)
16896 
      oprot.writeFieldEnd()
16897 
    oprot.writeFieldStop()
16898 
    oprot.writeStructEnd()
16899 
 
3431 rajveer 16900 
  def validate(self):
16901 
    return
16902 
 
16903 
 
2700 chandransh 16904 
  def __repr__(self):
16905 
    L = ['%s=%r' % (key, value)
16906 
      for key, value in self.__dict__.iteritems()]
16907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16908 
 
16909 
  def __eq__(self, other):
16910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16911 
 
16912 
  def __ne__(self, other):
16913 
    return not (self == other)
16914 
 
2690 chandransh 16915 
class processReturn_args:
16916 
  """
16917 
  Attributes:
16918 
   - returnOrderId
16919 
  """
16920 
 
16921 
  thrift_spec = (
16922 
    None, # 0
16923 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16924 
  )
16925 
 
16926 
  def __init__(self, returnOrderId=None,):
16927 
    self.returnOrderId = returnOrderId
16928 
 
16929 
  def read(self, iprot):
16930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16932 
      return
16933 
    iprot.readStructBegin()
16934 
    while True:
16935 
      (fname, ftype, fid) = iprot.readFieldBegin()
16936 
      if ftype == TType.STOP:
16937 
        break
16938 
      if fid == 1:
16939 
        if ftype == TType.I64:
16940 
          self.returnOrderId = iprot.readI64();
16941 
        else:
16942 
          iprot.skip(ftype)
16943 
      else:
16944 
        iprot.skip(ftype)
16945 
      iprot.readFieldEnd()
16946 
    iprot.readStructEnd()
16947 
 
16948 
  def write(self, oprot):
16949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16951 
      return
16952 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16953 
    if self.returnOrderId is not None:
2690 chandransh 16954 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16955 
      oprot.writeI64(self.returnOrderId)
16956 
      oprot.writeFieldEnd()
16957 
    oprot.writeFieldStop()
16958 
    oprot.writeStructEnd()
16959 
 
3431 rajveer 16960 
  def validate(self):
16961 
    return
16962 
 
16963 
 
2690 chandransh 16964 
  def __repr__(self):
16965 
    L = ['%s=%r' % (key, value)
16966 
      for key, value in self.__dict__.iteritems()]
16967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16968 
 
16969 
  def __eq__(self, other):
16970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16971 
 
16972 
  def __ne__(self, other):
16973 
    return not (self == other)
16974 
 
16975 
class processReturn_result:
16976 
  """
16977 
  Attributes:
16978 
   - ex
16979 
  """
16980 
 
16981 
  thrift_spec = (
16982 
    None, # 0
16983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16984 
  )
16985 
 
16986 
  def __init__(self, ex=None,):
16987 
    self.ex = ex
16988 
 
16989 
  def read(self, iprot):
16990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16992 
      return
16993 
    iprot.readStructBegin()
16994 
    while True:
16995 
      (fname, ftype, fid) = iprot.readFieldBegin()
16996 
      if ftype == TType.STOP:
16997 
        break
16998 
      if fid == 1:
16999 
        if ftype == TType.STRUCT:
17000 
          self.ex = TransactionServiceException()
17001 
          self.ex.read(iprot)
17002 
        else:
17003 
          iprot.skip(ftype)
17004 
      else:
17005 
        iprot.skip(ftype)
17006 
      iprot.readFieldEnd()
17007 
    iprot.readStructEnd()
17008 
 
17009 
  def write(self, oprot):
17010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17012 
      return
17013 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17014 
    if self.ex is not None:
2690 chandransh 17015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17016 
      self.ex.write(oprot)
17017 
      oprot.writeFieldEnd()
17018 
    oprot.writeFieldStop()
17019 
    oprot.writeStructEnd()
17020 
 
3431 rajveer 17021 
  def validate(self):
17022 
    return
17023 
 
17024 
 
2690 chandransh 17025 
  def __repr__(self):
17026 
    L = ['%s=%r' % (key, value)
17027 
      for key, value in self.__dict__.iteritems()]
17028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17029 
 
17030 
  def __eq__(self, other):
17031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17032 
 
17033 
  def __ne__(self, other):
17034 
    return not (self == other)
17035 
 
3451 chandransh 17036 
class updateWeight_args:
17037 
  """
17038 
  Attributes:
17039 
   - orderId
17040 
   - weight
17041 
  """
17042 
 
17043 
  thrift_spec = (
17044 
    None, # 0
17045 
    (1, TType.I64, 'orderId', None, None, ), # 1
17046 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17047 
  )
17048 
 
17049 
  def __init__(self, orderId=None, weight=None,):
17050 
    self.orderId = orderId
17051 
    self.weight = weight
17052 
 
17053 
  def read(self, iprot):
17054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17056 
      return
17057 
    iprot.readStructBegin()
17058 
    while True:
17059 
      (fname, ftype, fid) = iprot.readFieldBegin()
17060 
      if ftype == TType.STOP:
17061 
        break
17062 
      if fid == 1:
17063 
        if ftype == TType.I64:
17064 
          self.orderId = iprot.readI64();
17065 
        else:
17066 
          iprot.skip(ftype)
17067 
      elif fid == 2:
17068 
        if ftype == TType.DOUBLE:
17069 
          self.weight = iprot.readDouble();
17070 
        else:
17071 
          iprot.skip(ftype)
17072 
      else:
17073 
        iprot.skip(ftype)
17074 
      iprot.readFieldEnd()
17075 
    iprot.readStructEnd()
17076 
 
17077 
  def write(self, oprot):
17078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17080 
      return
17081 
    oprot.writeStructBegin('updateWeight_args')
17082 
    if self.orderId is not None:
17083 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17084 
      oprot.writeI64(self.orderId)
17085 
      oprot.writeFieldEnd()
17086 
    if self.weight is not None:
17087 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17088 
      oprot.writeDouble(self.weight)
17089 
      oprot.writeFieldEnd()
17090 
    oprot.writeFieldStop()
17091 
    oprot.writeStructEnd()
17092 
 
17093 
  def validate(self):
17094 
    return
17095 
 
17096 
 
17097 
  def __repr__(self):
17098 
    L = ['%s=%r' % (key, value)
17099 
      for key, value in self.__dict__.iteritems()]
17100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17101 
 
17102 
  def __eq__(self, other):
17103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17104 
 
17105 
  def __ne__(self, other):
17106 
    return not (self == other)
17107 
 
17108 
class updateWeight_result:
17109 
  """
17110 
  Attributes:
17111 
   - success
17112 
   - ex
17113 
  """
17114 
 
17115 
  thrift_spec = (
17116 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17118 
  )
17119 
 
17120 
  def __init__(self, success=None, ex=None,):
17121 
    self.success = success
17122 
    self.ex = ex
17123 
 
17124 
  def read(self, iprot):
17125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17127 
      return
17128 
    iprot.readStructBegin()
17129 
    while True:
17130 
      (fname, ftype, fid) = iprot.readFieldBegin()
17131 
      if ftype == TType.STOP:
17132 
        break
17133 
      if fid == 0:
17134 
        if ftype == TType.STRUCT:
17135 
          self.success = Order()
17136 
          self.success.read(iprot)
17137 
        else:
17138 
          iprot.skip(ftype)
17139 
      elif fid == 1:
17140 
        if ftype == TType.STRUCT:
17141 
          self.ex = TransactionServiceException()
17142 
          self.ex.read(iprot)
17143 
        else:
17144 
          iprot.skip(ftype)
17145 
      else:
17146 
        iprot.skip(ftype)
17147 
      iprot.readFieldEnd()
17148 
    iprot.readStructEnd()
17149 
 
17150 
  def write(self, oprot):
17151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17153 
      return
17154 
    oprot.writeStructBegin('updateWeight_result')
17155 
    if self.success is not None:
17156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17157 
      self.success.write(oprot)
17158 
      oprot.writeFieldEnd()
17159 
    if self.ex is not None:
17160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17161 
      self.ex.write(oprot)
17162 
      oprot.writeFieldEnd()
17163 
    oprot.writeFieldStop()
17164 
    oprot.writeStructEnd()
17165 
 
17166 
  def validate(self):
17167 
    return
17168 
 
17169 
 
17170 
  def __repr__(self):
17171 
    L = ['%s=%r' % (key, value)
17172 
      for key, value in self.__dict__.iteritems()]
17173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17174 
 
17175 
  def __eq__(self, other):
17176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17177 
 
17178 
  def __ne__(self, other):
17179 
    return not (self == other)
3469 chandransh 17180 
 
17181 
class changeItem_args:
17182 
  """
17183 
  Attributes:
17184 
   - orderId
17185 
   - itemId
17186 
  """
17187 
 
17188 
  thrift_spec = (
17189 
    None, # 0
17190 
    (1, TType.I64, 'orderId', None, None, ), # 1
17191 
    (2, TType.I64, 'itemId', None, None, ), # 2
17192 
  )
17193 
 
17194 
  def __init__(self, orderId=None, itemId=None,):
17195 
    self.orderId = orderId
17196 
    self.itemId = itemId
17197 
 
17198 
  def read(self, iprot):
17199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17201 
      return
17202 
    iprot.readStructBegin()
17203 
    while True:
17204 
      (fname, ftype, fid) = iprot.readFieldBegin()
17205 
      if ftype == TType.STOP:
17206 
        break
17207 
      if fid == 1:
17208 
        if ftype == TType.I64:
17209 
          self.orderId = iprot.readI64();
17210 
        else:
17211 
          iprot.skip(ftype)
17212 
      elif fid == 2:
17213 
        if ftype == TType.I64:
17214 
          self.itemId = iprot.readI64();
17215 
        else:
17216 
          iprot.skip(ftype)
17217 
      else:
17218 
        iprot.skip(ftype)
17219 
      iprot.readFieldEnd()
17220 
    iprot.readStructEnd()
17221 
 
17222 
  def write(self, oprot):
17223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17225 
      return
17226 
    oprot.writeStructBegin('changeItem_args')
17227 
    if self.orderId is not None:
17228 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17229 
      oprot.writeI64(self.orderId)
17230 
      oprot.writeFieldEnd()
17231 
    if self.itemId is not None:
17232 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17233 
      oprot.writeI64(self.itemId)
17234 
      oprot.writeFieldEnd()
17235 
    oprot.writeFieldStop()
17236 
    oprot.writeStructEnd()
17237 
 
17238 
  def validate(self):
17239 
    return
17240 
 
17241 
 
17242 
  def __repr__(self):
17243 
    L = ['%s=%r' % (key, value)
17244 
      for key, value in self.__dict__.iteritems()]
17245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17246 
 
17247 
  def __eq__(self, other):
17248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17249 
 
17250 
  def __ne__(self, other):
17251 
    return not (self == other)
17252 
 
17253 
class changeItem_result:
17254 
  """
17255 
  Attributes:
17256 
   - success
17257 
   - ex
17258 
  """
17259 
 
17260 
  thrift_spec = (
17261 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17263 
  )
17264 
 
17265 
  def __init__(self, success=None, ex=None,):
17266 
    self.success = success
17267 
    self.ex = ex
17268 
 
17269 
  def read(self, iprot):
17270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17272 
      return
17273 
    iprot.readStructBegin()
17274 
    while True:
17275 
      (fname, ftype, fid) = iprot.readFieldBegin()
17276 
      if ftype == TType.STOP:
17277 
        break
17278 
      if fid == 0:
17279 
        if ftype == TType.STRUCT:
17280 
          self.success = Order()
17281 
          self.success.read(iprot)
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      elif fid == 1:
17285 
        if ftype == TType.STRUCT:
17286 
          self.ex = TransactionServiceException()
17287 
          self.ex.read(iprot)
17288 
        else:
17289 
          iprot.skip(ftype)
17290 
      else:
17291 
        iprot.skip(ftype)
17292 
      iprot.readFieldEnd()
17293 
    iprot.readStructEnd()
17294 
 
17295 
  def write(self, oprot):
17296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17298 
      return
17299 
    oprot.writeStructBegin('changeItem_result')
17300 
    if self.success is not None:
17301 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17302 
      self.success.write(oprot)
17303 
      oprot.writeFieldEnd()
17304 
    if self.ex is not None:
17305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17306 
      self.ex.write(oprot)
17307 
      oprot.writeFieldEnd()
17308 
    oprot.writeFieldStop()
17309 
    oprot.writeStructEnd()
17310 
 
17311 
  def validate(self):
17312 
    return
17313 
 
17314 
 
17315 
  def __repr__(self):
17316 
    L = ['%s=%r' % (key, value)
17317 
      for key, value in self.__dict__.iteritems()]
17318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17319 
 
17320 
  def __eq__(self, other):
17321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17322 
 
17323 
  def __ne__(self, other):
17324 
    return not (self == other)
17325 
 
17326 
class shiftToWarehouse_args:
17327 
  """
17328 
  Attributes:
17329 
   - orderId
17330 
   - warehouseId
17331 
  """
17332 
 
17333 
  thrift_spec = (
17334 
    None, # 0
17335 
    (1, TType.I64, 'orderId', None, None, ), # 1
17336 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17337 
  )
17338 
 
17339 
  def __init__(self, orderId=None, warehouseId=None,):
17340 
    self.orderId = orderId
17341 
    self.warehouseId = warehouseId
17342 
 
17343 
  def read(self, iprot):
17344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17346 
      return
17347 
    iprot.readStructBegin()
17348 
    while True:
17349 
      (fname, ftype, fid) = iprot.readFieldBegin()
17350 
      if ftype == TType.STOP:
17351 
        break
17352 
      if fid == 1:
17353 
        if ftype == TType.I64:
17354 
          self.orderId = iprot.readI64();
17355 
        else:
17356 
          iprot.skip(ftype)
17357 
      elif fid == 2:
17358 
        if ftype == TType.I64:
17359 
          self.warehouseId = iprot.readI64();
17360 
        else:
17361 
          iprot.skip(ftype)
17362 
      else:
17363 
        iprot.skip(ftype)
17364 
      iprot.readFieldEnd()
17365 
    iprot.readStructEnd()
17366 
 
17367 
  def write(self, oprot):
17368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17370 
      return
17371 
    oprot.writeStructBegin('shiftToWarehouse_args')
17372 
    if self.orderId is not None:
17373 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17374 
      oprot.writeI64(self.orderId)
17375 
      oprot.writeFieldEnd()
17376 
    if self.warehouseId is not None:
17377 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17378 
      oprot.writeI64(self.warehouseId)
17379 
      oprot.writeFieldEnd()
17380 
    oprot.writeFieldStop()
17381 
    oprot.writeStructEnd()
17382 
 
17383 
  def validate(self):
17384 
    return
17385 
 
17386 
 
17387 
  def __repr__(self):
17388 
    L = ['%s=%r' % (key, value)
17389 
      for key, value in self.__dict__.iteritems()]
17390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17391 
 
17392 
  def __eq__(self, other):
17393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17394 
 
17395 
  def __ne__(self, other):
17396 
    return not (self == other)
17397 
 
17398 
class shiftToWarehouse_result:
17399 
  """
17400 
  Attributes:
17401 
   - success
17402 
   - ex
17403 
  """
17404 
 
17405 
  thrift_spec = (
17406 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17407 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17408 
  )
17409 
 
17410 
  def __init__(self, success=None, ex=None,):
17411 
    self.success = success
17412 
    self.ex = ex
17413 
 
17414 
  def read(self, iprot):
17415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17417 
      return
17418 
    iprot.readStructBegin()
17419 
    while True:
17420 
      (fname, ftype, fid) = iprot.readFieldBegin()
17421 
      if ftype == TType.STOP:
17422 
        break
17423 
      if fid == 0:
17424 
        if ftype == TType.STRUCT:
17425 
          self.success = Order()
17426 
          self.success.read(iprot)
17427 
        else:
17428 
          iprot.skip(ftype)
17429 
      elif fid == 1:
17430 
        if ftype == TType.STRUCT:
17431 
          self.ex = TransactionServiceException()
17432 
          self.ex.read(iprot)
17433 
        else:
17434 
          iprot.skip(ftype)
17435 
      else:
17436 
        iprot.skip(ftype)
17437 
      iprot.readFieldEnd()
17438 
    iprot.readStructEnd()
17439 
 
17440 
  def write(self, oprot):
17441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17443 
      return
17444 
    oprot.writeStructBegin('shiftToWarehouse_result')
17445 
    if self.success is not None:
17446 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17447 
      self.success.write(oprot)
17448 
      oprot.writeFieldEnd()
17449 
    if self.ex is not None:
17450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17451 
      self.ex.write(oprot)
17452 
      oprot.writeFieldEnd()
17453 
    oprot.writeFieldStop()
17454 
    oprot.writeStructEnd()
17455 
 
17456 
  def validate(self):
17457 
    return
17458 
 
17459 
 
17460 
  def __repr__(self):
17461 
    L = ['%s=%r' % (key, value)
17462 
      for key, value in self.__dict__.iteritems()]
17463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17464 
 
17465 
  def __eq__(self, other):
17466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17467 
 
17468 
  def __ne__(self, other):
17469 
    return not (self == other)
3553 chandransh 17470 
 
17471 
class addDelayReason_args:
17472 
  """
17473 
  Attributes:
17474 
   - orderId
17475 
   - delayReason
3986 chandransh 17476 
   - furtherDelay
4647 rajveer 17477 
   - delayReasonText
3553 chandransh 17478 
  """
17479 
 
17480 
  thrift_spec = (
17481 
    None, # 0
17482 
    (1, TType.I64, 'orderId', None, None, ), # 1
17483 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17484 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17485 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17486 
  )
17487 
 
4647 rajveer 17488 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17489 
    self.orderId = orderId
17490 
    self.delayReason = delayReason
3986 chandransh 17491 
    self.furtherDelay = furtherDelay
4647 rajveer 17492 
    self.delayReasonText = delayReasonText
3553 chandransh 17493 
 
17494 
  def read(self, iprot):
17495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17497 
      return
17498 
    iprot.readStructBegin()
17499 
    while True:
17500 
      (fname, ftype, fid) = iprot.readFieldBegin()
17501 
      if ftype == TType.STOP:
17502 
        break
17503 
      if fid == 1:
17504 
        if ftype == TType.I64:
17505 
          self.orderId = iprot.readI64();
17506 
        else:
17507 
          iprot.skip(ftype)
17508 
      elif fid == 2:
17509 
        if ftype == TType.I32:
17510 
          self.delayReason = iprot.readI32();
17511 
        else:
17512 
          iprot.skip(ftype)
3986 chandransh 17513 
      elif fid == 3:
17514 
        if ftype == TType.I64:
17515 
          self.furtherDelay = iprot.readI64();
17516 
        else:
17517 
          iprot.skip(ftype)
4647 rajveer 17518 
      elif fid == 4:
17519 
        if ftype == TType.STRING:
17520 
          self.delayReasonText = iprot.readString();
17521 
        else:
17522 
          iprot.skip(ftype)
3553 chandransh 17523 
      else:
17524 
        iprot.skip(ftype)
17525 
      iprot.readFieldEnd()
17526 
    iprot.readStructEnd()
17527 
 
17528 
  def write(self, oprot):
17529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17531 
      return
17532 
    oprot.writeStructBegin('addDelayReason_args')
17533 
    if self.orderId is not None:
17534 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17535 
      oprot.writeI64(self.orderId)
17536 
      oprot.writeFieldEnd()
17537 
    if self.delayReason is not None:
17538 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
17539 
      oprot.writeI32(self.delayReason)
17540 
      oprot.writeFieldEnd()
3986 chandransh 17541 
    if self.furtherDelay is not None:
17542 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
17543 
      oprot.writeI64(self.furtherDelay)
17544 
      oprot.writeFieldEnd()
4647 rajveer 17545 
    if self.delayReasonText is not None:
17546 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
17547 
      oprot.writeString(self.delayReasonText)
17548 
      oprot.writeFieldEnd()
3553 chandransh 17549 
    oprot.writeFieldStop()
17550 
    oprot.writeStructEnd()
17551 
 
17552 
  def validate(self):
17553 
    return
17554 
 
17555 
 
17556 
  def __repr__(self):
17557 
    L = ['%s=%r' % (key, value)
17558 
      for key, value in self.__dict__.iteritems()]
17559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17560 
 
17561 
  def __eq__(self, other):
17562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17563 
 
17564 
  def __ne__(self, other):
17565 
    return not (self == other)
17566 
 
17567 
class addDelayReason_result:
17568 
  """
17569 
  Attributes:
17570 
   - success
17571 
   - ex
17572 
  """
17573 
 
17574 
  thrift_spec = (
17575 
    (0, TType.BOOL, 'success', None, None, ), # 0
17576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17577 
  )
17578 
 
17579 
  def __init__(self, success=None, ex=None,):
17580 
    self.success = success
17581 
    self.ex = ex
17582 
 
17583 
  def read(self, iprot):
17584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17586 
      return
17587 
    iprot.readStructBegin()
17588 
    while True:
17589 
      (fname, ftype, fid) = iprot.readFieldBegin()
17590 
      if ftype == TType.STOP:
17591 
        break
17592 
      if fid == 0:
17593 
        if ftype == TType.BOOL:
17594 
          self.success = iprot.readBool();
17595 
        else:
17596 
          iprot.skip(ftype)
17597 
      elif fid == 1:
17598 
        if ftype == TType.STRUCT:
17599 
          self.ex = TransactionServiceException()
17600 
          self.ex.read(iprot)
17601 
        else:
17602 
          iprot.skip(ftype)
17603 
      else:
17604 
        iprot.skip(ftype)
17605 
      iprot.readFieldEnd()
17606 
    iprot.readStructEnd()
17607 
 
17608 
  def write(self, oprot):
17609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17611 
      return
17612 
    oprot.writeStructBegin('addDelayReason_result')
17613 
    if self.success is not None:
17614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17615 
      oprot.writeBool(self.success)
17616 
      oprot.writeFieldEnd()
17617 
    if self.ex is not None:
17618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17619 
      self.ex.write(oprot)
17620 
      oprot.writeFieldEnd()
17621 
    oprot.writeFieldStop()
17622 
    oprot.writeStructEnd()
17623 
 
17624 
  def validate(self):
17625 
    return
17626 
 
17627 
 
17628 
  def __repr__(self):
17629 
    L = ['%s=%r' % (key, value)
17630 
      for key, value in self.__dict__.iteritems()]
17631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17632 
 
17633 
  def __eq__(self, other):
17634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17635 
 
17636 
  def __ne__(self, other):
17637 
    return not (self == other)
3956 chandransh 17638 
 
17639 
class reconcileCodCollection_args:
17640 
  """
17641 
  Attributes:
17642 
   - collectedAmountMap
17643 
   - xferBy
17644 
   - xferTxnId
17645 
   - xferDate
17646 
  """
17647 
 
17648 
  thrift_spec = (
17649 
    None, # 0
17650 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17651 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17652 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17653 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17654 
  )
17655 
 
17656 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17657 
    self.collectedAmountMap = collectedAmountMap
17658 
    self.xferBy = xferBy
17659 
    self.xferTxnId = xferTxnId
17660 
    self.xferDate = xferDate
17661 
 
17662 
  def read(self, iprot):
17663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17665 
      return
17666 
    iprot.readStructBegin()
17667 
    while True:
17668 
      (fname, ftype, fid) = iprot.readFieldBegin()
17669 
      if ftype == TType.STOP:
17670 
        break
17671 
      if fid == 1:
17672 
        if ftype == TType.MAP:
17673 
          self.collectedAmountMap = {}
5481 phani.kuma 17674 
          (_ktype397, _vtype398, _size396 ) = iprot.readMapBegin()
17675 
          for _i400 in xrange(_size396):
17676 
            _key401 = iprot.readString();
17677 
            _val402 = iprot.readDouble();
17678 
            self.collectedAmountMap[_key401] = _val402
3956 chandransh 17679 
          iprot.readMapEnd()
17680 
        else:
17681 
          iprot.skip(ftype)
17682 
      elif fid == 2:
17683 
        if ftype == TType.STRING:
17684 
          self.xferBy = iprot.readString();
17685 
        else:
17686 
          iprot.skip(ftype)
17687 
      elif fid == 3:
17688 
        if ftype == TType.STRING:
17689 
          self.xferTxnId = iprot.readString();
17690 
        else:
17691 
          iprot.skip(ftype)
17692 
      elif fid == 4:
17693 
        if ftype == TType.I64:
17694 
          self.xferDate = iprot.readI64();
17695 
        else:
17696 
          iprot.skip(ftype)
17697 
      else:
17698 
        iprot.skip(ftype)
17699 
      iprot.readFieldEnd()
17700 
    iprot.readStructEnd()
17701 
 
17702 
  def write(self, oprot):
17703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17705 
      return
17706 
    oprot.writeStructBegin('reconcileCodCollection_args')
17707 
    if self.collectedAmountMap is not None:
17708 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17709 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5481 phani.kuma 17710 
      for kiter403,viter404 in self.collectedAmountMap.items():
17711 
        oprot.writeString(kiter403)
17712 
        oprot.writeDouble(viter404)
3956 chandransh 17713 
      oprot.writeMapEnd()
17714 
      oprot.writeFieldEnd()
17715 
    if self.xferBy is not None:
17716 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17717 
      oprot.writeString(self.xferBy)
17718 
      oprot.writeFieldEnd()
17719 
    if self.xferTxnId is not None:
17720 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17721 
      oprot.writeString(self.xferTxnId)
17722 
      oprot.writeFieldEnd()
17723 
    if self.xferDate is not None:
17724 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17725 
      oprot.writeI64(self.xferDate)
17726 
      oprot.writeFieldEnd()
17727 
    oprot.writeFieldStop()
17728 
    oprot.writeStructEnd()
17729 
 
17730 
  def validate(self):
17731 
    return
17732 
 
17733 
 
17734 
  def __repr__(self):
17735 
    L = ['%s=%r' % (key, value)
17736 
      for key, value in self.__dict__.iteritems()]
17737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17738 
 
17739 
  def __eq__(self, other):
17740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17741 
 
17742 
  def __ne__(self, other):
17743 
    return not (self == other)
17744 
 
17745 
class reconcileCodCollection_result:
17746 
  """
17747 
  Attributes:
17748 
   - success
17749 
   - ex
17750 
  """
17751 
 
17752 
  thrift_spec = (
17753 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17755 
  )
17756 
 
17757 
  def __init__(self, success=None, ex=None,):
17758 
    self.success = success
17759 
    self.ex = ex
17760 
 
17761 
  def read(self, iprot):
17762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17764 
      return
17765 
    iprot.readStructBegin()
17766 
    while True:
17767 
      (fname, ftype, fid) = iprot.readFieldBegin()
17768 
      if ftype == TType.STOP:
17769 
        break
17770 
      if fid == 0:
17771 
        if ftype == TType.MAP:
17772 
          self.success = {}
5481 phani.kuma 17773 
          (_ktype406, _vtype407, _size405 ) = iprot.readMapBegin()
17774 
          for _i409 in xrange(_size405):
17775 
            _key410 = iprot.readString();
17776 
            _val411 = iprot.readString();
17777 
            self.success[_key410] = _val411
3956 chandransh 17778 
          iprot.readMapEnd()
17779 
        else:
17780 
          iprot.skip(ftype)
17781 
      elif fid == 1:
17782 
        if ftype == TType.STRUCT:
17783 
          self.ex = TransactionServiceException()
17784 
          self.ex.read(iprot)
17785 
        else:
17786 
          iprot.skip(ftype)
17787 
      else:
17788 
        iprot.skip(ftype)
17789 
      iprot.readFieldEnd()
17790 
    iprot.readStructEnd()
17791 
 
17792 
  def write(self, oprot):
17793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17795 
      return
17796 
    oprot.writeStructBegin('reconcileCodCollection_result')
17797 
    if self.success is not None:
17798 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17799 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5481 phani.kuma 17800 
      for kiter412,viter413 in self.success.items():
17801 
        oprot.writeString(kiter412)
17802 
        oprot.writeString(viter413)
3956 chandransh 17803 
      oprot.writeMapEnd()
17804 
      oprot.writeFieldEnd()
17805 
    if self.ex is not None:
17806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17807 
      self.ex.write(oprot)
17808 
      oprot.writeFieldEnd()
17809 
    oprot.writeFieldStop()
17810 
    oprot.writeStructEnd()
17811 
 
17812 
  def validate(self):
17813 
    return
17814 
 
17815 
 
17816 
  def __repr__(self):
17817 
    L = ['%s=%r' % (key, value)
17818 
      for key, value in self.__dict__.iteritems()]
17819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17820 
 
17821 
  def __eq__(self, other):
17822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17823 
 
17824 
  def __ne__(self, other):
17825 
    return not (self == other)
4008 mandeep.dh 17826 
 
17827 
class getTransactionsRequiringExtraProcessing_args:
17828 
  """
17829 
  Attributes:
17830 
   - category
17831 
  """
17832 
 
17833 
  thrift_spec = (
17834 
    None, # 0
17835 
    (1, TType.I32, 'category', None, None, ), # 1
17836 
  )
17837 
 
17838 
  def __init__(self, category=None,):
17839 
    self.category = category
17840 
 
17841 
  def read(self, iprot):
17842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17844 
      return
17845 
    iprot.readStructBegin()
17846 
    while True:
17847 
      (fname, ftype, fid) = iprot.readFieldBegin()
17848 
      if ftype == TType.STOP:
17849 
        break
17850 
      if fid == 1:
17851 
        if ftype == TType.I32:
17852 
          self.category = iprot.readI32();
17853 
        else:
17854 
          iprot.skip(ftype)
17855 
      else:
17856 
        iprot.skip(ftype)
17857 
      iprot.readFieldEnd()
17858 
    iprot.readStructEnd()
17859 
 
17860 
  def write(self, oprot):
17861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17863 
      return
17864 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17865 
    if self.category is not None:
17866 
      oprot.writeFieldBegin('category', TType.I32, 1)
17867 
      oprot.writeI32(self.category)
17868 
      oprot.writeFieldEnd()
17869 
    oprot.writeFieldStop()
17870 
    oprot.writeStructEnd()
17871 
 
17872 
  def validate(self):
17873 
    return
17874 
 
17875 
 
17876 
  def __repr__(self):
17877 
    L = ['%s=%r' % (key, value)
17878 
      for key, value in self.__dict__.iteritems()]
17879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17880 
 
17881 
  def __eq__(self, other):
17882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17883 
 
17884 
  def __ne__(self, other):
17885 
    return not (self == other)
17886 
 
17887 
class getTransactionsRequiringExtraProcessing_result:
17888 
  """
17889 
  Attributes:
17890 
   - success
17891 
  """
17892 
 
17893 
  thrift_spec = (
17894 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17895 
  )
17896 
 
17897 
  def __init__(self, success=None,):
17898 
    self.success = success
17899 
 
17900 
  def read(self, iprot):
17901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17903 
      return
17904 
    iprot.readStructBegin()
17905 
    while True:
17906 
      (fname, ftype, fid) = iprot.readFieldBegin()
17907 
      if ftype == TType.STOP:
17908 
        break
17909 
      if fid == 0:
17910 
        if ftype == TType.LIST:
17911 
          self.success = []
5481 phani.kuma 17912 
          (_etype417, _size414) = iprot.readListBegin()
17913 
          for _i418 in xrange(_size414):
17914 
            _elem419 = iprot.readI64();
17915 
            self.success.append(_elem419)
4008 mandeep.dh 17916 
          iprot.readListEnd()
17917 
        else:
17918 
          iprot.skip(ftype)
17919 
      else:
17920 
        iprot.skip(ftype)
17921 
      iprot.readFieldEnd()
17922 
    iprot.readStructEnd()
17923 
 
17924 
  def write(self, oprot):
17925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17927 
      return
17928 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17929 
    if self.success is not None:
17930 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17931 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 17932 
      for iter420 in self.success:
17933 
        oprot.writeI64(iter420)
4008 mandeep.dh 17934 
      oprot.writeListEnd()
17935 
      oprot.writeFieldEnd()
17936 
    oprot.writeFieldStop()
17937 
    oprot.writeStructEnd()
17938 
 
17939 
  def validate(self):
17940 
    return
17941 
 
17942 
 
17943 
  def __repr__(self):
17944 
    L = ['%s=%r' % (key, value)
17945 
      for key, value in self.__dict__.iteritems()]
17946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17947 
 
17948 
  def __eq__(self, other):
17949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17950 
 
17951 
  def __ne__(self, other):
17952 
    return not (self == other)
17953 
 
17954 
class markTransactionAsProcessed_args:
17955 
  """
17956 
  Attributes:
17957 
   - transactionId
17958 
   - category
17959 
  """
17960 
 
17961 
  thrift_spec = (
17962 
    None, # 0
17963 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17964 
    (2, TType.I32, 'category', None, None, ), # 2
17965 
  )
17966 
 
17967 
  def __init__(self, transactionId=None, category=None,):
17968 
    self.transactionId = transactionId
17969 
    self.category = category
17970 
 
17971 
  def read(self, iprot):
17972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17974 
      return
17975 
    iprot.readStructBegin()
17976 
    while True:
17977 
      (fname, ftype, fid) = iprot.readFieldBegin()
17978 
      if ftype == TType.STOP:
17979 
        break
17980 
      if fid == 1:
17981 
        if ftype == TType.I64:
17982 
          self.transactionId = iprot.readI64();
17983 
        else:
17984 
          iprot.skip(ftype)
17985 
      elif fid == 2:
17986 
        if ftype == TType.I32:
17987 
          self.category = iprot.readI32();
17988 
        else:
17989 
          iprot.skip(ftype)
17990 
      else:
17991 
        iprot.skip(ftype)
17992 
      iprot.readFieldEnd()
17993 
    iprot.readStructEnd()
17994 
 
17995 
  def write(self, oprot):
17996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17998 
      return
17999 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18000 
    if self.transactionId is not None:
18001 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18002 
      oprot.writeI64(self.transactionId)
18003 
      oprot.writeFieldEnd()
18004 
    if self.category is not None:
18005 
      oprot.writeFieldBegin('category', TType.I32, 2)
18006 
      oprot.writeI32(self.category)
18007 
      oprot.writeFieldEnd()
18008 
    oprot.writeFieldStop()
18009 
    oprot.writeStructEnd()
18010 
 
18011 
  def validate(self):
18012 
    return
18013 
 
18014 
 
18015 
  def __repr__(self):
18016 
    L = ['%s=%r' % (key, value)
18017 
      for key, value in self.__dict__.iteritems()]
18018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18019 
 
18020 
  def __eq__(self, other):
18021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18022 
 
18023 
  def __ne__(self, other):
18024 
    return not (self == other)
18025 
 
18026 
class markTransactionAsProcessed_result:
18027 
 
18028 
  thrift_spec = (
18029 
  )
18030 
 
18031 
  def read(self, iprot):
18032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18034 
      return
18035 
    iprot.readStructBegin()
18036 
    while True:
18037 
      (fname, ftype, fid) = iprot.readFieldBegin()
18038 
      if ftype == TType.STOP:
18039 
        break
18040 
      else:
18041 
        iprot.skip(ftype)
18042 
      iprot.readFieldEnd()
18043 
    iprot.readStructEnd()
18044 
 
18045 
  def write(self, oprot):
18046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18048 
      return
18049 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18050 
    oprot.writeFieldStop()
18051 
    oprot.writeStructEnd()
18052 
 
18053 
  def validate(self):
18054 
    return
18055 
 
18056 
 
18057 
  def __repr__(self):
18058 
    L = ['%s=%r' % (key, value)
18059 
      for key, value in self.__dict__.iteritems()]
18060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18061 
 
18062 
  def __eq__(self, other):
18063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18064 
 
18065 
  def __ne__(self, other):
18066 
    return not (self == other)
4018 chandransh 18067 
 
18068 
class getItemWiseRiskyOrdersCount_args:
18069 
 
18070 
  thrift_spec = (
18071 
  )
18072 
 
18073 
  def read(self, iprot):
18074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18076 
      return
18077 
    iprot.readStructBegin()
18078 
    while True:
18079 
      (fname, ftype, fid) = iprot.readFieldBegin()
18080 
      if ftype == TType.STOP:
18081 
        break
18082 
      else:
18083 
        iprot.skip(ftype)
18084 
      iprot.readFieldEnd()
18085 
    iprot.readStructEnd()
18086 
 
18087 
  def write(self, oprot):
18088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18090 
      return
18091 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18092 
    oprot.writeFieldStop()
18093 
    oprot.writeStructEnd()
18094 
 
18095 
  def validate(self):
18096 
    return
18097 
 
18098 
 
18099 
  def __repr__(self):
18100 
    L = ['%s=%r' % (key, value)
18101 
      for key, value in self.__dict__.iteritems()]
18102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18103 
 
18104 
  def __eq__(self, other):
18105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18106 
 
18107 
  def __ne__(self, other):
18108 
    return not (self == other)
18109 
 
18110 
class getItemWiseRiskyOrdersCount_result:
18111 
  """
18112 
  Attributes:
18113 
   - success
18114 
  """
18115 
 
18116 
  thrift_spec = (
18117 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18118 
  )
18119 
 
18120 
  def __init__(self, success=None,):
18121 
    self.success = success
18122 
 
18123 
  def read(self, iprot):
18124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18126 
      return
18127 
    iprot.readStructBegin()
18128 
    while True:
18129 
      (fname, ftype, fid) = iprot.readFieldBegin()
18130 
      if ftype == TType.STOP:
18131 
        break
18132 
      if fid == 0:
18133 
        if ftype == TType.MAP:
18134 
          self.success = {}
5481 phani.kuma 18135 
          (_ktype422, _vtype423, _size421 ) = iprot.readMapBegin()
18136 
          for _i425 in xrange(_size421):
18137 
            _key426 = iprot.readI64();
18138 
            _val427 = iprot.readI64();
18139 
            self.success[_key426] = _val427
4018 chandransh 18140 
          iprot.readMapEnd()
18141 
        else:
18142 
          iprot.skip(ftype)
18143 
      else:
18144 
        iprot.skip(ftype)
18145 
      iprot.readFieldEnd()
18146 
    iprot.readStructEnd()
18147 
 
18148 
  def write(self, oprot):
18149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18151 
      return
18152 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
18153 
    if self.success is not None:
18154 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18155 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 18156 
      for kiter428,viter429 in self.success.items():
18157 
        oprot.writeI64(kiter428)
18158 
        oprot.writeI64(viter429)
4018 chandransh 18159 
      oprot.writeMapEnd()
18160 
      oprot.writeFieldEnd()
18161 
    oprot.writeFieldStop()
18162 
    oprot.writeStructEnd()
18163 
 
18164 
  def validate(self):
18165 
    return
18166 
 
18167 
 
18168 
  def __repr__(self):
18169 
    L = ['%s=%r' % (key, value)
18170 
      for key, value in self.__dict__.iteritems()]
18171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18172 
 
18173 
  def __eq__(self, other):
18174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18175 
 
18176 
  def __ne__(self, other):
18177 
    return not (self == other)
4247 rajveer 18178 
 
4295 varun.gupt 18179 
class getOrdersForItemIds_args:
18180 
  """
18181 
  Attributes:
18182 
   - itemIds
18183 
  """
18184 
 
18185 
  thrift_spec = (
18186 
    None, # 0
18187 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18188 
  )
18189 
 
18190 
  def __init__(self, itemIds=None,):
18191 
    self.itemIds = itemIds
18192 
 
18193 
  def read(self, iprot):
18194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18196 
      return
18197 
    iprot.readStructBegin()
18198 
    while True:
18199 
      (fname, ftype, fid) = iprot.readFieldBegin()
18200 
      if ftype == TType.STOP:
18201 
        break
18202 
      if fid == 1:
18203 
        if ftype == TType.LIST:
18204 
          self.itemIds = []
5481 phani.kuma 18205 
          (_etype433, _size430) = iprot.readListBegin()
18206 
          for _i434 in xrange(_size430):
18207 
            _elem435 = iprot.readI64();
18208 
            self.itemIds.append(_elem435)
4295 varun.gupt 18209 
          iprot.readListEnd()
18210 
        else:
18211 
          iprot.skip(ftype)
18212 
      else:
18213 
        iprot.skip(ftype)
18214 
      iprot.readFieldEnd()
18215 
    iprot.readStructEnd()
18216 
 
18217 
  def write(self, oprot):
18218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18220 
      return
18221 
    oprot.writeStructBegin('getOrdersForItemIds_args')
18222 
    if self.itemIds is not None:
18223 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18224 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5481 phani.kuma 18225 
      for iter436 in self.itemIds:
18226 
        oprot.writeI64(iter436)
4295 varun.gupt 18227 
      oprot.writeListEnd()
18228 
      oprot.writeFieldEnd()
18229 
    oprot.writeFieldStop()
18230 
    oprot.writeStructEnd()
18231 
 
18232 
  def validate(self):
18233 
    return
18234 
 
18235 
 
18236 
  def __repr__(self):
18237 
    L = ['%s=%r' % (key, value)
18238 
      for key, value in self.__dict__.iteritems()]
18239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18240 
 
18241 
  def __eq__(self, other):
18242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18243 
 
18244 
  def __ne__(self, other):
18245 
    return not (self == other)
18246 
 
18247 
class getOrdersForItemIds_result:
18248 
  """
18249 
  Attributes:
18250 
   - success
18251 
  """
18252 
 
18253 
  thrift_spec = (
18254 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18255 
  )
18256 
 
18257 
  def __init__(self, success=None,):
18258 
    self.success = success
18259 
 
18260 
  def read(self, iprot):
18261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18263 
      return
18264 
    iprot.readStructBegin()
18265 
    while True:
18266 
      (fname, ftype, fid) = iprot.readFieldBegin()
18267 
      if ftype == TType.STOP:
18268 
        break
18269 
      if fid == 0:
18270 
        if ftype == TType.LIST:
18271 
          self.success = []
5481 phani.kuma 18272 
          (_etype440, _size437) = iprot.readListBegin()
18273 
          for _i441 in xrange(_size437):
18274 
            _elem442 = Order()
18275 
            _elem442.read(iprot)
18276 
            self.success.append(_elem442)
4295 varun.gupt 18277 
          iprot.readListEnd()
18278 
        else:
18279 
          iprot.skip(ftype)
18280 
      else:
18281 
        iprot.skip(ftype)
18282 
      iprot.readFieldEnd()
18283 
    iprot.readStructEnd()
18284 
 
18285 
  def write(self, oprot):
18286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18288 
      return
18289 
    oprot.writeStructBegin('getOrdersForItemIds_result')
18290 
    if self.success is not None:
18291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 18293 
      for iter443 in self.success:
18294 
        iter443.write(oprot)
4295 varun.gupt 18295 
      oprot.writeListEnd()
18296 
      oprot.writeFieldEnd()
18297 
    oprot.writeFieldStop()
18298 
    oprot.writeStructEnd()
18299 
 
18300 
  def validate(self):
18301 
    return
18302 
 
18303 
 
18304 
  def __repr__(self):
18305 
    L = ['%s=%r' % (key, value)
18306 
      for key, value in self.__dict__.iteritems()]
18307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18308 
 
18309 
  def __eq__(self, other):
18310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18311 
 
18312 
  def __ne__(self, other):
18313 
    return not (self == other)
18314 
 
4247 rajveer 18315 
class markOrderCancellationRequestReceived_args:
18316 
  """
18317 
  Attributes:
18318 
   - orderId
18319 
  """
18320 
 
18321 
  thrift_spec = (
18322 
    None, # 0
18323 
    (1, TType.I64, 'orderId', None, None, ), # 1
18324 
  )
18325 
 
18326 
  def __init__(self, orderId=None,):
18327 
    self.orderId = orderId
18328 
 
18329 
  def read(self, iprot):
18330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18332 
      return
18333 
    iprot.readStructBegin()
18334 
    while True:
18335 
      (fname, ftype, fid) = iprot.readFieldBegin()
18336 
      if ftype == TType.STOP:
18337 
        break
18338 
      if fid == 1:
18339 
        if ftype == TType.I64:
18340 
          self.orderId = iprot.readI64();
18341 
        else:
18342 
          iprot.skip(ftype)
18343 
      else:
18344 
        iprot.skip(ftype)
18345 
      iprot.readFieldEnd()
18346 
    iprot.readStructEnd()
18347 
 
18348 
  def write(self, oprot):
18349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18351 
      return
18352 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18353 
    if self.orderId is not None:
18354 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18355 
      oprot.writeI64(self.orderId)
18356 
      oprot.writeFieldEnd()
18357 
    oprot.writeFieldStop()
18358 
    oprot.writeStructEnd()
18359 
 
18360 
  def validate(self):
18361 
    return
18362 
 
18363 
 
18364 
  def __repr__(self):
18365 
    L = ['%s=%r' % (key, value)
18366 
      for key, value in self.__dict__.iteritems()]
18367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18368 
 
18369 
  def __eq__(self, other):
18370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18371 
 
18372 
  def __ne__(self, other):
18373 
    return not (self == other)
18374 
 
18375 
class markOrderCancellationRequestReceived_result:
18376 
  """
18377 
  Attributes:
18378 
   - ex
18379 
  """
18380 
 
18381 
  thrift_spec = (
18382 
    None, # 0
18383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18384 
  )
18385 
 
18386 
  def __init__(self, ex=None,):
18387 
    self.ex = ex
18388 
 
18389 
  def read(self, iprot):
18390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18392 
      return
18393 
    iprot.readStructBegin()
18394 
    while True:
18395 
      (fname, ftype, fid) = iprot.readFieldBegin()
18396 
      if ftype == TType.STOP:
18397 
        break
18398 
      if fid == 1:
18399 
        if ftype == TType.STRUCT:
18400 
          self.ex = TransactionServiceException()
18401 
          self.ex.read(iprot)
18402 
        else:
18403 
          iprot.skip(ftype)
18404 
      else:
18405 
        iprot.skip(ftype)
18406 
      iprot.readFieldEnd()
18407 
    iprot.readStructEnd()
18408 
 
18409 
  def write(self, oprot):
18410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18412 
      return
18413 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18414 
    if self.ex is not None:
18415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18416 
      self.ex.write(oprot)
18417 
      oprot.writeFieldEnd()
18418 
    oprot.writeFieldStop()
18419 
    oprot.writeStructEnd()
18420 
 
18421 
  def validate(self):
18422 
    return
18423 
 
18424 
 
18425 
  def __repr__(self):
18426 
    L = ['%s=%r' % (key, value)
18427 
      for key, value in self.__dict__.iteritems()]
18428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18429 
 
18430 
  def __eq__(self, other):
18431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18432 
 
18433 
  def __ne__(self, other):
18434 
    return not (self == other)
18435 
 
18436 
class markOrderCancellationRequestConfirmed_args:
18437 
  """
18438 
  Attributes:
18439 
   - orderId
18440 
  """
18441 
 
18442 
  thrift_spec = (
18443 
    None, # 0
18444 
    (1, TType.I64, 'orderId', None, None, ), # 1
18445 
  )
18446 
 
18447 
  def __init__(self, orderId=None,):
18448 
    self.orderId = orderId
18449 
 
18450 
  def read(self, iprot):
18451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18453 
      return
18454 
    iprot.readStructBegin()
18455 
    while True:
18456 
      (fname, ftype, fid) = iprot.readFieldBegin()
18457 
      if ftype == TType.STOP:
18458 
        break
18459 
      if fid == 1:
18460 
        if ftype == TType.I64:
18461 
          self.orderId = iprot.readI64();
18462 
        else:
18463 
          iprot.skip(ftype)
18464 
      else:
18465 
        iprot.skip(ftype)
18466 
      iprot.readFieldEnd()
18467 
    iprot.readStructEnd()
18468 
 
18469 
  def write(self, oprot):
18470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18472 
      return
18473 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18474 
    if self.orderId is not None:
18475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18476 
      oprot.writeI64(self.orderId)
18477 
      oprot.writeFieldEnd()
18478 
    oprot.writeFieldStop()
18479 
    oprot.writeStructEnd()
18480 
 
18481 
  def validate(self):
18482 
    return
18483 
 
18484 
 
18485 
  def __repr__(self):
18486 
    L = ['%s=%r' % (key, value)
18487 
      for key, value in self.__dict__.iteritems()]
18488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18489 
 
18490 
  def __eq__(self, other):
18491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18492 
 
18493 
  def __ne__(self, other):
18494 
    return not (self == other)
18495 
 
18496 
class markOrderCancellationRequestConfirmed_result:
18497 
  """
18498 
  Attributes:
18499 
   - ex
18500 
  """
18501 
 
18502 
  thrift_spec = (
18503 
    None, # 0
18504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18505 
  )
18506 
 
18507 
  def __init__(self, ex=None,):
18508 
    self.ex = ex
18509 
 
18510 
  def read(self, iprot):
18511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18513 
      return
18514 
    iprot.readStructBegin()
18515 
    while True:
18516 
      (fname, ftype, fid) = iprot.readFieldBegin()
18517 
      if ftype == TType.STOP:
18518 
        break
18519 
      if fid == 1:
18520 
        if ftype == TType.STRUCT:
18521 
          self.ex = TransactionServiceException()
18522 
          self.ex.read(iprot)
18523 
        else:
18524 
          iprot.skip(ftype)
18525 
      else:
18526 
        iprot.skip(ftype)
18527 
      iprot.readFieldEnd()
18528 
    iprot.readStructEnd()
18529 
 
18530 
  def write(self, oprot):
18531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18533 
      return
18534 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
18535 
    if self.ex is not None:
18536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18537 
      self.ex.write(oprot)
18538 
      oprot.writeFieldEnd()
18539 
    oprot.writeFieldStop()
18540 
    oprot.writeStructEnd()
18541 
 
18542 
  def validate(self):
18543 
    return
18544 
 
18545 
 
18546 
  def __repr__(self):
18547 
    L = ['%s=%r' % (key, value)
18548 
      for key, value in self.__dict__.iteritems()]
18549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18550 
 
18551 
  def __eq__(self, other):
18552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18553 
 
18554 
  def __ne__(self, other):
18555 
    return not (self == other)
18556 
 
18557 
class markOrderCancellationRequestDenied_args:
18558 
  """
18559 
  Attributes:
18560 
   - orderId
18561 
  """
18562 
 
18563 
  thrift_spec = (
18564 
    None, # 0
18565 
    (1, TType.I64, 'orderId', None, None, ), # 1
18566 
  )
18567 
 
18568 
  def __init__(self, orderId=None,):
18569 
    self.orderId = orderId
18570 
 
18571 
  def read(self, iprot):
18572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18574 
      return
18575 
    iprot.readStructBegin()
18576 
    while True:
18577 
      (fname, ftype, fid) = iprot.readFieldBegin()
18578 
      if ftype == TType.STOP:
18579 
        break
18580 
      if fid == 1:
18581 
        if ftype == TType.I64:
18582 
          self.orderId = iprot.readI64();
18583 
        else:
18584 
          iprot.skip(ftype)
18585 
      else:
18586 
        iprot.skip(ftype)
18587 
      iprot.readFieldEnd()
18588 
    iprot.readStructEnd()
18589 
 
18590 
  def write(self, oprot):
18591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18593 
      return
18594 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18595 
    if self.orderId is not None:
18596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18597 
      oprot.writeI64(self.orderId)
18598 
      oprot.writeFieldEnd()
18599 
    oprot.writeFieldStop()
18600 
    oprot.writeStructEnd()
18601 
 
18602 
  def validate(self):
18603 
    return
18604 
 
18605 
 
18606 
  def __repr__(self):
18607 
    L = ['%s=%r' % (key, value)
18608 
      for key, value in self.__dict__.iteritems()]
18609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18610 
 
18611 
  def __eq__(self, other):
18612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18613 
 
18614 
  def __ne__(self, other):
18615 
    return not (self == other)
18616 
 
18617 
class markOrderCancellationRequestDenied_result:
18618 
  """
18619 
  Attributes:
18620 
   - ex
18621 
  """
18622 
 
18623 
  thrift_spec = (
18624 
    None, # 0
18625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18626 
  )
18627 
 
18628 
  def __init__(self, ex=None,):
18629 
    self.ex = ex
18630 
 
18631 
  def read(self, iprot):
18632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18634 
      return
18635 
    iprot.readStructBegin()
18636 
    while True:
18637 
      (fname, ftype, fid) = iprot.readFieldBegin()
18638 
      if ftype == TType.STOP:
18639 
        break
18640 
      if fid == 1:
18641 
        if ftype == TType.STRUCT:
18642 
          self.ex = TransactionServiceException()
18643 
          self.ex.read(iprot)
18644 
        else:
18645 
          iprot.skip(ftype)
18646 
      else:
18647 
        iprot.skip(ftype)
18648 
      iprot.readFieldEnd()
18649 
    iprot.readStructEnd()
18650 
 
18651 
  def write(self, oprot):
18652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18654 
      return
18655 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18656 
    if self.ex is not None:
18657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18658 
      self.ex.write(oprot)
18659 
      oprot.writeFieldEnd()
18660 
    oprot.writeFieldStop()
18661 
    oprot.writeStructEnd()
18662 
 
18663 
  def validate(self):
18664 
    return
18665 
 
18666 
 
18667 
  def __repr__(self):
18668 
    L = ['%s=%r' % (key, value)
18669 
      for key, value in self.__dict__.iteritems()]
18670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18671 
 
18672 
  def __eq__(self, other):
18673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18674 
 
18675 
  def __ne__(self, other):
18676 
    return not (self == other)
18677 
 
4258 rajveer 18678 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18679 
  """
18680 
  Attributes:
4258 rajveer 18681 
   - transactionId
4247 rajveer 18682 
  """
18683 
 
18684 
  thrift_spec = (
18685 
    None, # 0
4258 rajveer 18686 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18687 
  )
18688 
 
4258 rajveer 18689 
  def __init__(self, transactionId=None,):
18690 
    self.transactionId = transactionId
4247 rajveer 18691 
 
18692 
  def read(self, iprot):
18693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18695 
      return
18696 
    iprot.readStructBegin()
18697 
    while True:
18698 
      (fname, ftype, fid) = iprot.readFieldBegin()
18699 
      if ftype == TType.STOP:
18700 
        break
18701 
      if fid == 1:
18702 
        if ftype == TType.I64:
4258 rajveer 18703 
          self.transactionId = iprot.readI64();
4247 rajveer 18704 
        else:
18705 
          iprot.skip(ftype)
18706 
      else:
18707 
        iprot.skip(ftype)
18708 
      iprot.readFieldEnd()
18709 
    iprot.readStructEnd()
18710 
 
18711 
  def write(self, oprot):
18712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18714 
      return
4258 rajveer 18715 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18716 
    if self.transactionId is not None:
18717 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18718 
      oprot.writeI64(self.transactionId)
4247 rajveer 18719 
      oprot.writeFieldEnd()
18720 
    oprot.writeFieldStop()
18721 
    oprot.writeStructEnd()
18722 
 
18723 
  def validate(self):
18724 
    return
18725 
 
18726 
 
18727 
  def __repr__(self):
18728 
    L = ['%s=%r' % (key, value)
18729 
      for key, value in self.__dict__.iteritems()]
18730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18731 
 
18732 
  def __eq__(self, other):
18733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18734 
 
18735 
  def __ne__(self, other):
18736 
    return not (self == other)
18737 
 
4258 rajveer 18738 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18739 
  """
18740 
  Attributes:
18741 
   - ex
18742 
  """
18743 
 
18744 
  thrift_spec = (
18745 
    None, # 0
18746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18747 
  )
18748 
 
18749 
  def __init__(self, ex=None,):
18750 
    self.ex = ex
18751 
 
18752 
  def read(self, iprot):
18753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18755 
      return
18756 
    iprot.readStructBegin()
18757 
    while True:
18758 
      (fname, ftype, fid) = iprot.readFieldBegin()
18759 
      if ftype == TType.STOP:
18760 
        break
18761 
      if fid == 1:
18762 
        if ftype == TType.STRUCT:
18763 
          self.ex = TransactionServiceException()
18764 
          self.ex.read(iprot)
18765 
        else:
18766 
          iprot.skip(ftype)
18767 
      else:
18768 
        iprot.skip(ftype)
18769 
      iprot.readFieldEnd()
18770 
    iprot.readStructEnd()
18771 
 
18772 
  def write(self, oprot):
18773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18775 
      return
4258 rajveer 18776 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18777 
    if self.ex is not None:
18778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18779 
      self.ex.write(oprot)
18780 
      oprot.writeFieldEnd()
18781 
    oprot.writeFieldStop()
18782 
    oprot.writeStructEnd()
18783 
 
18784 
  def validate(self):
18785 
    return
18786 
 
18787 
 
18788 
  def __repr__(self):
18789 
    L = ['%s=%r' % (key, value)
18790 
      for key, value in self.__dict__.iteritems()]
18791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18792 
 
18793 
  def __eq__(self, other):
18794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18795 
 
18796 
  def __ne__(self, other):
18797 
    return not (self == other)
4259 anupam.sin 18798 
 
18799 
class refundTransaction_args:
18800 
  """
18801 
  Attributes:
18802 
   - transactionId
18803 
   - refundedBy
18804 
   - reason
18805 
  """
18806 
 
18807 
  thrift_spec = (
18808 
    None, # 0
18809 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18810 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18811 
    (3, TType.STRING, 'reason', None, None, ), # 3
18812 
  )
18813 
 
18814 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18815 
    self.transactionId = transactionId
18816 
    self.refundedBy = refundedBy
18817 
    self.reason = reason
18818 
 
18819 
  def read(self, iprot):
18820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18822 
      return
18823 
    iprot.readStructBegin()
18824 
    while True:
18825 
      (fname, ftype, fid) = iprot.readFieldBegin()
18826 
      if ftype == TType.STOP:
18827 
        break
18828 
      if fid == 1:
18829 
        if ftype == TType.I64:
18830 
          self.transactionId = iprot.readI64();
18831 
        else:
18832 
          iprot.skip(ftype)
18833 
      elif fid == 2:
18834 
        if ftype == TType.STRING:
18835 
          self.refundedBy = iprot.readString();
18836 
        else:
18837 
          iprot.skip(ftype)
18838 
      elif fid == 3:
18839 
        if ftype == TType.STRING:
18840 
          self.reason = iprot.readString();
18841 
        else:
18842 
          iprot.skip(ftype)
18843 
      else:
18844 
        iprot.skip(ftype)
18845 
      iprot.readFieldEnd()
18846 
    iprot.readStructEnd()
18847 
 
18848 
  def write(self, oprot):
18849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18851 
      return
18852 
    oprot.writeStructBegin('refundTransaction_args')
18853 
    if self.transactionId is not None:
18854 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18855 
      oprot.writeI64(self.transactionId)
18856 
      oprot.writeFieldEnd()
18857 
    if self.refundedBy is not None:
18858 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18859 
      oprot.writeString(self.refundedBy)
18860 
      oprot.writeFieldEnd()
18861 
    if self.reason is not None:
18862 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18863 
      oprot.writeString(self.reason)
18864 
      oprot.writeFieldEnd()
18865 
    oprot.writeFieldStop()
18866 
    oprot.writeStructEnd()
18867 
 
18868 
  def validate(self):
18869 
    return
18870 
 
18871 
 
18872 
  def __repr__(self):
18873 
    L = ['%s=%r' % (key, value)
18874 
      for key, value in self.__dict__.iteritems()]
18875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18876 
 
18877 
  def __eq__(self, other):
18878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18879 
 
18880 
  def __ne__(self, other):
18881 
    return not (self == other)
18882 
 
18883 
class refundTransaction_result:
18884 
  """
18885 
  Attributes:
18886 
   - ex
18887 
  """
18888 
 
18889 
  thrift_spec = (
18890 
    None, # 0
18891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18892 
  )
18893 
 
18894 
  def __init__(self, ex=None,):
18895 
    self.ex = ex
18896 
 
18897 
  def read(self, iprot):
18898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18900 
      return
18901 
    iprot.readStructBegin()
18902 
    while True:
18903 
      (fname, ftype, fid) = iprot.readFieldBegin()
18904 
      if ftype == TType.STOP:
18905 
        break
18906 
      if fid == 1:
18907 
        if ftype == TType.STRUCT:
18908 
          self.ex = TransactionServiceException()
18909 
          self.ex.read(iprot)
18910 
        else:
18911 
          iprot.skip(ftype)
18912 
      else:
18913 
        iprot.skip(ftype)
18914 
      iprot.readFieldEnd()
18915 
    iprot.readStructEnd()
18916 
 
18917 
  def write(self, oprot):
18918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18920 
      return
18921 
    oprot.writeStructBegin('refundTransaction_result')
18922 
    if self.ex is not None:
18923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18924 
      self.ex.write(oprot)
18925 
      oprot.writeFieldEnd()
18926 
    oprot.writeFieldStop()
18927 
    oprot.writeStructEnd()
18928 
 
18929 
  def validate(self):
18930 
    return
18931 
 
18932 
 
18933 
  def __repr__(self):
18934 
    L = ['%s=%r' % (key, value)
18935 
      for key, value in self.__dict__.iteritems()]
18936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18937 
 
18938 
  def __eq__(self, other):
18939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18940 
 
18941 
  def __ne__(self, other):
18942 
    return not (self == other)
4285 rajveer 18943 
 
4324 mandeep.dh 18944 
class updateShipmentAddress_args:
18945 
  """
18946 
  Attributes:
18947 
   - orderId
18948 
   - addressId
18949 
  """
18950 
 
18951 
  thrift_spec = (
18952 
    None, # 0
18953 
    (1, TType.I64, 'orderId', None, None, ), # 1
18954 
    (2, TType.I64, 'addressId', None, None, ), # 2
18955 
  )
18956 
 
18957 
  def __init__(self, orderId=None, addressId=None,):
18958 
    self.orderId = orderId
18959 
    self.addressId = addressId
18960 
 
18961 
  def read(self, iprot):
18962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18964 
      return
18965 
    iprot.readStructBegin()
18966 
    while True:
18967 
      (fname, ftype, fid) = iprot.readFieldBegin()
18968 
      if ftype == TType.STOP:
18969 
        break
18970 
      if fid == 1:
18971 
        if ftype == TType.I64:
18972 
          self.orderId = iprot.readI64();
18973 
        else:
18974 
          iprot.skip(ftype)
18975 
      elif fid == 2:
18976 
        if ftype == TType.I64:
18977 
          self.addressId = iprot.readI64();
18978 
        else:
18979 
          iprot.skip(ftype)
18980 
      else:
18981 
        iprot.skip(ftype)
18982 
      iprot.readFieldEnd()
18983 
    iprot.readStructEnd()
18984 
 
18985 
  def write(self, oprot):
18986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18988 
      return
18989 
    oprot.writeStructBegin('updateShipmentAddress_args')
18990 
    if self.orderId is not None:
18991 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18992 
      oprot.writeI64(self.orderId)
18993 
      oprot.writeFieldEnd()
18994 
    if self.addressId is not None:
18995 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18996 
      oprot.writeI64(self.addressId)
18997 
      oprot.writeFieldEnd()
18998 
    oprot.writeFieldStop()
18999 
    oprot.writeStructEnd()
19000 
 
19001 
  def validate(self):
19002 
    return
19003 
 
19004 
 
19005 
  def __repr__(self):
19006 
    L = ['%s=%r' % (key, value)
19007 
      for key, value in self.__dict__.iteritems()]
19008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19009 
 
19010 
  def __eq__(self, other):
19011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19012 
 
19013 
  def __ne__(self, other):
19014 
    return not (self == other)
19015 
 
19016 
class updateShipmentAddress_result:
19017 
  """
19018 
  Attributes:
19019 
   - ex
19020 
  """
19021 
 
19022 
  thrift_spec = (
19023 
    None, # 0
19024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19025 
  )
19026 
 
19027 
  def __init__(self, ex=None,):
19028 
    self.ex = ex
19029 
 
19030 
  def read(self, iprot):
19031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19033 
      return
19034 
    iprot.readStructBegin()
19035 
    while True:
19036 
      (fname, ftype, fid) = iprot.readFieldBegin()
19037 
      if ftype == TType.STOP:
19038 
        break
19039 
      if fid == 1:
19040 
        if ftype == TType.STRUCT:
19041 
          self.ex = TransactionServiceException()
19042 
          self.ex.read(iprot)
19043 
        else:
19044 
          iprot.skip(ftype)
19045 
      else:
19046 
        iprot.skip(ftype)
19047 
      iprot.readFieldEnd()
19048 
    iprot.readStructEnd()
19049 
 
19050 
  def write(self, oprot):
19051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19053 
      return
19054 
    oprot.writeStructBegin('updateShipmentAddress_result')
19055 
    if self.ex is not None:
19056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19057 
      self.ex.write(oprot)
19058 
      oprot.writeFieldEnd()
19059 
    oprot.writeFieldStop()
19060 
    oprot.writeStructEnd()
19061 
 
19062 
  def validate(self):
19063 
    return
19064 
 
19065 
 
19066 
  def __repr__(self):
19067 
    L = ['%s=%r' % (key, value)
19068 
      for key, value in self.__dict__.iteritems()]
19069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19070 
 
19071 
  def __eq__(self, other):
19072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19073 
 
19074 
  def __ne__(self, other):
19075 
    return not (self == other)
19076 
 
4285 rajveer 19077 
class acceptOrdersForItemId_args:
19078 
  """
19079 
  Attributes:
19080 
   - itemId
19081 
   - inventory
19082 
  """
19083 
 
19084 
  thrift_spec = (
19085 
    None, # 0
19086 
    (1, TType.I64, 'itemId', None, None, ), # 1
19087 
    (2, TType.I64, 'inventory', None, None, ), # 2
19088 
  )
19089 
 
19090 
  def __init__(self, itemId=None, inventory=None,):
19091 
    self.itemId = itemId
19092 
    self.inventory = inventory
19093 
 
19094 
  def read(self, iprot):
19095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19097 
      return
19098 
    iprot.readStructBegin()
19099 
    while True:
19100 
      (fname, ftype, fid) = iprot.readFieldBegin()
19101 
      if ftype == TType.STOP:
19102 
        break
19103 
      if fid == 1:
19104 
        if ftype == TType.I64:
19105 
          self.itemId = iprot.readI64();
19106 
        else:
19107 
          iprot.skip(ftype)
19108 
      elif fid == 2:
19109 
        if ftype == TType.I64:
19110 
          self.inventory = iprot.readI64();
19111 
        else:
19112 
          iprot.skip(ftype)
19113 
      else:
19114 
        iprot.skip(ftype)
19115 
      iprot.readFieldEnd()
19116 
    iprot.readStructEnd()
19117 
 
19118 
  def write(self, oprot):
19119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19121 
      return
19122 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19123 
    if self.itemId is not None:
19124 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19125 
      oprot.writeI64(self.itemId)
19126 
      oprot.writeFieldEnd()
19127 
    if self.inventory is not None:
19128 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19129 
      oprot.writeI64(self.inventory)
19130 
      oprot.writeFieldEnd()
19131 
    oprot.writeFieldStop()
19132 
    oprot.writeStructEnd()
19133 
 
19134 
  def validate(self):
19135 
    return
19136 
 
19137 
 
19138 
  def __repr__(self):
19139 
    L = ['%s=%r' % (key, value)
19140 
      for key, value in self.__dict__.iteritems()]
19141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19142 
 
19143 
  def __eq__(self, other):
19144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19145 
 
19146 
  def __ne__(self, other):
19147 
    return not (self == other)
19148 
 
19149 
class acceptOrdersForItemId_result:
19150 
  """
19151 
  Attributes:
19152 
   - success
19153 
   - ex
19154 
  """
19155 
 
19156 
  thrift_spec = (
19157 
    (0, TType.BOOL, 'success', None, None, ), # 0
19158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19159 
  )
19160 
 
19161 
  def __init__(self, success=None, ex=None,):
19162 
    self.success = success
19163 
    self.ex = ex
19164 
 
19165 
  def read(self, iprot):
19166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19168 
      return
19169 
    iprot.readStructBegin()
19170 
    while True:
19171 
      (fname, ftype, fid) = iprot.readFieldBegin()
19172 
      if ftype == TType.STOP:
19173 
        break
19174 
      if fid == 0:
19175 
        if ftype == TType.BOOL:
19176 
          self.success = iprot.readBool();
19177 
        else:
19178 
          iprot.skip(ftype)
19179 
      elif fid == 1:
19180 
        if ftype == TType.STRUCT:
19181 
          self.ex = TransactionServiceException()
19182 
          self.ex.read(iprot)
19183 
        else:
19184 
          iprot.skip(ftype)
19185 
      else:
19186 
        iprot.skip(ftype)
19187 
      iprot.readFieldEnd()
19188 
    iprot.readStructEnd()
19189 
 
19190 
  def write(self, oprot):
19191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19193 
      return
19194 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
19195 
    if self.success is not None:
19196 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19197 
      oprot.writeBool(self.success)
19198 
      oprot.writeFieldEnd()
19199 
    if self.ex is not None:
19200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19201 
      self.ex.write(oprot)
19202 
      oprot.writeFieldEnd()
19203 
    oprot.writeFieldStop()
19204 
    oprot.writeStructEnd()
19205 
 
19206 
  def validate(self):
19207 
    return
19208 
 
19209 
 
19210 
  def __repr__(self):
19211 
    L = ['%s=%r' % (key, value)
19212 
      for key, value in self.__dict__.iteritems()]
19213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19214 
 
19215 
  def __eq__(self, other):
19216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19217 
 
19218 
  def __ne__(self, other):
19219 
    return not (self == other)
4303 rajveer 19220 
 
19221 
class markOrdersAsPORaised_args:
19222 
  """
19223 
  Attributes:
19224 
   - vendorId
19225 
   - itemId
19226 
   - quantity
19227 
   - estimate
4369 rajveer 19228 
   - isReminder
4303 rajveer 19229 
  """
19230 
 
19231 
  thrift_spec = (
19232 
    None, # 0
19233 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19234 
    (2, TType.I64, 'itemId', None, None, ), # 2
19235 
    (3, TType.I64, 'quantity', None, None, ), # 3
19236 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19237 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19238 
  )
19239 
 
4369 rajveer 19240 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19241 
    self.vendorId = vendorId
19242 
    self.itemId = itemId
19243 
    self.quantity = quantity
19244 
    self.estimate = estimate
4369 rajveer 19245 
    self.isReminder = isReminder
4303 rajveer 19246 
 
19247 
  def read(self, iprot):
19248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19250 
      return
19251 
    iprot.readStructBegin()
19252 
    while True:
19253 
      (fname, ftype, fid) = iprot.readFieldBegin()
19254 
      if ftype == TType.STOP:
19255 
        break
19256 
      if fid == 1:
19257 
        if ftype == TType.I64:
19258 
          self.vendorId = iprot.readI64();
19259 
        else:
19260 
          iprot.skip(ftype)
19261 
      elif fid == 2:
19262 
        if ftype == TType.I64:
19263 
          self.itemId = iprot.readI64();
19264 
        else:
19265 
          iprot.skip(ftype)
19266 
      elif fid == 3:
19267 
        if ftype == TType.I64:
19268 
          self.quantity = iprot.readI64();
19269 
        else:
19270 
          iprot.skip(ftype)
19271 
      elif fid == 4:
19272 
        if ftype == TType.I64:
19273 
          self.estimate = iprot.readI64();
19274 
        else:
19275 
          iprot.skip(ftype)
4369 rajveer 19276 
      elif fid == 5:
19277 
        if ftype == TType.BOOL:
19278 
          self.isReminder = iprot.readBool();
19279 
        else:
19280 
          iprot.skip(ftype)
4303 rajveer 19281 
      else:
19282 
        iprot.skip(ftype)
19283 
      iprot.readFieldEnd()
19284 
    iprot.readStructEnd()
19285 
 
19286 
  def write(self, oprot):
19287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19289 
      return
19290 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
19291 
    if self.vendorId is not None:
19292 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19293 
      oprot.writeI64(self.vendorId)
19294 
      oprot.writeFieldEnd()
19295 
    if self.itemId is not None:
19296 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19297 
      oprot.writeI64(self.itemId)
19298 
      oprot.writeFieldEnd()
19299 
    if self.quantity is not None:
19300 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19301 
      oprot.writeI64(self.quantity)
19302 
      oprot.writeFieldEnd()
19303 
    if self.estimate is not None:
19304 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19305 
      oprot.writeI64(self.estimate)
19306 
      oprot.writeFieldEnd()
4369 rajveer 19307 
    if self.isReminder is not None:
19308 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19309 
      oprot.writeBool(self.isReminder)
19310 
      oprot.writeFieldEnd()
4303 rajveer 19311 
    oprot.writeFieldStop()
19312 
    oprot.writeStructEnd()
19313 
 
19314 
  def validate(self):
19315 
    return
19316 
 
19317 
 
19318 
  def __repr__(self):
19319 
    L = ['%s=%r' % (key, value)
19320 
      for key, value in self.__dict__.iteritems()]
19321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19322 
 
19323 
  def __eq__(self, other):
19324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19325 
 
19326 
  def __ne__(self, other):
19327 
    return not (self == other)
19328 
 
19329 
class markOrdersAsPORaised_result:
19330 
  """
19331 
  Attributes:
19332 
   - ex
19333 
  """
19334 
 
19335 
  thrift_spec = (
19336 
    None, # 0
19337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19338 
  )
19339 
 
19340 
  def __init__(self, ex=None,):
19341 
    self.ex = ex
19342 
 
19343 
  def read(self, iprot):
19344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19346 
      return
19347 
    iprot.readStructBegin()
19348 
    while True:
19349 
      (fname, ftype, fid) = iprot.readFieldBegin()
19350 
      if ftype == TType.STOP:
19351 
        break
19352 
      if fid == 1:
19353 
        if ftype == TType.STRUCT:
19354 
          self.ex = TransactionServiceException()
19355 
          self.ex.read(iprot)
19356 
        else:
19357 
          iprot.skip(ftype)
19358 
      else:
19359 
        iprot.skip(ftype)
19360 
      iprot.readFieldEnd()
19361 
    iprot.readStructEnd()
19362 
 
19363 
  def write(self, oprot):
19364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19366 
      return
19367 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19368 
    if self.ex is not None:
19369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19370 
      self.ex.write(oprot)
19371 
      oprot.writeFieldEnd()
19372 
    oprot.writeFieldStop()
19373 
    oprot.writeStructEnd()
19374 
 
19375 
  def validate(self):
19376 
    return
19377 
 
19378 
 
19379 
  def __repr__(self):
19380 
    L = ['%s=%r' % (key, value)
19381 
      for key, value in self.__dict__.iteritems()]
19382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19383 
 
19384 
  def __eq__(self, other):
19385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19386 
 
19387 
  def __ne__(self, other):
19388 
    return not (self == other)
19389 
 
19390 
class markOrdersAsReversalInitiated_args:
19391 
  """
19392 
  Attributes:
19393 
   - vendorId
19394 
   - itemId
19395 
   - quantity
19396 
   - estimate
4369 rajveer 19397 
   - isReminder
4303 rajveer 19398 
  """
19399 
 
19400 
  thrift_spec = (
19401 
    None, # 0
19402 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19403 
    (2, TType.I64, 'itemId', None, None, ), # 2
19404 
    (3, TType.I64, 'quantity', None, None, ), # 3
19405 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19406 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19407 
  )
19408 
 
4369 rajveer 19409 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19410 
    self.vendorId = vendorId
19411 
    self.itemId = itemId
19412 
    self.quantity = quantity
19413 
    self.estimate = estimate
4369 rajveer 19414 
    self.isReminder = isReminder
4303 rajveer 19415 
 
19416 
  def read(self, iprot):
19417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19419 
      return
19420 
    iprot.readStructBegin()
19421 
    while True:
19422 
      (fname, ftype, fid) = iprot.readFieldBegin()
19423 
      if ftype == TType.STOP:
19424 
        break
19425 
      if fid == 1:
19426 
        if ftype == TType.I64:
19427 
          self.vendorId = iprot.readI64();
19428 
        else:
19429 
          iprot.skip(ftype)
19430 
      elif fid == 2:
19431 
        if ftype == TType.I64:
19432 
          self.itemId = iprot.readI64();
19433 
        else:
19434 
          iprot.skip(ftype)
19435 
      elif fid == 3:
19436 
        if ftype == TType.I64:
19437 
          self.quantity = iprot.readI64();
19438 
        else:
19439 
          iprot.skip(ftype)
19440 
      elif fid == 4:
19441 
        if ftype == TType.I64:
19442 
          self.estimate = iprot.readI64();
19443 
        else:
19444 
          iprot.skip(ftype)
4369 rajveer 19445 
      elif fid == 5:
19446 
        if ftype == TType.BOOL:
19447 
          self.isReminder = iprot.readBool();
19448 
        else:
19449 
          iprot.skip(ftype)
4303 rajveer 19450 
      else:
19451 
        iprot.skip(ftype)
19452 
      iprot.readFieldEnd()
19453 
    iprot.readStructEnd()
19454 
 
19455 
  def write(self, oprot):
19456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19458 
      return
19459 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19460 
    if self.vendorId is not None:
19461 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19462 
      oprot.writeI64(self.vendorId)
19463 
      oprot.writeFieldEnd()
19464 
    if self.itemId is not None:
19465 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19466 
      oprot.writeI64(self.itemId)
19467 
      oprot.writeFieldEnd()
19468 
    if self.quantity is not None:
19469 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19470 
      oprot.writeI64(self.quantity)
19471 
      oprot.writeFieldEnd()
19472 
    if self.estimate is not None:
19473 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19474 
      oprot.writeI64(self.estimate)
19475 
      oprot.writeFieldEnd()
4369 rajveer 19476 
    if self.isReminder is not None:
19477 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19478 
      oprot.writeBool(self.isReminder)
19479 
      oprot.writeFieldEnd()
4303 rajveer 19480 
    oprot.writeFieldStop()
19481 
    oprot.writeStructEnd()
19482 
 
19483 
  def validate(self):
19484 
    return
19485 
 
19486 
 
19487 
  def __repr__(self):
19488 
    L = ['%s=%r' % (key, value)
19489 
      for key, value in self.__dict__.iteritems()]
19490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19491 
 
19492 
  def __eq__(self, other):
19493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19494 
 
19495 
  def __ne__(self, other):
19496 
    return not (self == other)
19497 
 
19498 
class markOrdersAsReversalInitiated_result:
19499 
  """
19500 
  Attributes:
19501 
   - ex
19502 
  """
19503 
 
19504 
  thrift_spec = (
19505 
    None, # 0
19506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19507 
  )
19508 
 
19509 
  def __init__(self, ex=None,):
19510 
    self.ex = ex
19511 
 
19512 
  def read(self, iprot):
19513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19515 
      return
19516 
    iprot.readStructBegin()
19517 
    while True:
19518 
      (fname, ftype, fid) = iprot.readFieldBegin()
19519 
      if ftype == TType.STOP:
19520 
        break
19521 
      if fid == 1:
19522 
        if ftype == TType.STRUCT:
19523 
          self.ex = TransactionServiceException()
19524 
          self.ex.read(iprot)
19525 
        else:
19526 
          iprot.skip(ftype)
19527 
      else:
19528 
        iprot.skip(ftype)
19529 
      iprot.readFieldEnd()
19530 
    iprot.readStructEnd()
19531 
 
19532 
  def write(self, oprot):
19533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19535 
      return
19536 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
19537 
    if self.ex is not None:
19538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19539 
      self.ex.write(oprot)
19540 
      oprot.writeFieldEnd()
19541 
    oprot.writeFieldStop()
19542 
    oprot.writeStructEnd()
19543 
 
19544 
  def validate(self):
19545 
    return
19546 
 
19547 
 
19548 
  def __repr__(self):
19549 
    L = ['%s=%r' % (key, value)
19550 
      for key, value in self.__dict__.iteritems()]
19551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19552 
 
19553 
  def __eq__(self, other):
19554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19555 
 
19556 
  def __ne__(self, other):
19557 
    return not (self == other)
19558 
 
19559 
class markOrdersAsNotAvailabke_args:
19560 
  """
19561 
  Attributes:
19562 
   - vendorId
19563 
   - itemId
19564 
   - quantity
19565 
   - estimate
4369 rajveer 19566 
   - isReminder
4303 rajveer 19567 
  """
19568 
 
19569 
  thrift_spec = (
19570 
    None, # 0
19571 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19572 
    (2, TType.I64, 'itemId', None, None, ), # 2
19573 
    (3, TType.I64, 'quantity', None, None, ), # 3
19574 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19575 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19576 
  )
19577 
 
4369 rajveer 19578 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19579 
    self.vendorId = vendorId
19580 
    self.itemId = itemId
19581 
    self.quantity = quantity
19582 
    self.estimate = estimate
4369 rajveer 19583 
    self.isReminder = isReminder
4303 rajveer 19584 
 
19585 
  def read(self, iprot):
19586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19588 
      return
19589 
    iprot.readStructBegin()
19590 
    while True:
19591 
      (fname, ftype, fid) = iprot.readFieldBegin()
19592 
      if ftype == TType.STOP:
19593 
        break
19594 
      if fid == 1:
19595 
        if ftype == TType.I64:
19596 
          self.vendorId = iprot.readI64();
19597 
        else:
19598 
          iprot.skip(ftype)
19599 
      elif fid == 2:
19600 
        if ftype == TType.I64:
19601 
          self.itemId = iprot.readI64();
19602 
        else:
19603 
          iprot.skip(ftype)
19604 
      elif fid == 3:
19605 
        if ftype == TType.I64:
19606 
          self.quantity = iprot.readI64();
19607 
        else:
19608 
          iprot.skip(ftype)
19609 
      elif fid == 4:
19610 
        if ftype == TType.I64:
19611 
          self.estimate = iprot.readI64();
19612 
        else:
19613 
          iprot.skip(ftype)
4369 rajveer 19614 
      elif fid == 5:
19615 
        if ftype == TType.BOOL:
19616 
          self.isReminder = iprot.readBool();
19617 
        else:
19618 
          iprot.skip(ftype)
4303 rajveer 19619 
      else:
19620 
        iprot.skip(ftype)
19621 
      iprot.readFieldEnd()
19622 
    iprot.readStructEnd()
19623 
 
19624 
  def write(self, oprot):
19625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19627 
      return
19628 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19629 
    if self.vendorId is not None:
19630 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19631 
      oprot.writeI64(self.vendorId)
19632 
      oprot.writeFieldEnd()
19633 
    if self.itemId is not None:
19634 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19635 
      oprot.writeI64(self.itemId)
19636 
      oprot.writeFieldEnd()
19637 
    if self.quantity is not None:
19638 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19639 
      oprot.writeI64(self.quantity)
19640 
      oprot.writeFieldEnd()
19641 
    if self.estimate is not None:
19642 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19643 
      oprot.writeI64(self.estimate)
19644 
      oprot.writeFieldEnd()
4369 rajveer 19645 
    if self.isReminder is not None:
19646 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19647 
      oprot.writeBool(self.isReminder)
19648 
      oprot.writeFieldEnd()
4303 rajveer 19649 
    oprot.writeFieldStop()
19650 
    oprot.writeStructEnd()
19651 
 
19652 
  def validate(self):
19653 
    return
19654 
 
19655 
 
19656 
  def __repr__(self):
19657 
    L = ['%s=%r' % (key, value)
19658 
      for key, value in self.__dict__.iteritems()]
19659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19660 
 
19661 
  def __eq__(self, other):
19662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19663 
 
19664 
  def __ne__(self, other):
19665 
    return not (self == other)
19666 
 
19667 
class markOrdersAsNotAvailabke_result:
19668 
  """
19669 
  Attributes:
19670 
   - ex
19671 
  """
19672 
 
19673 
  thrift_spec = (
19674 
    None, # 0
19675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19676 
  )
19677 
 
19678 
  def __init__(self, ex=None,):
19679 
    self.ex = ex
19680 
 
19681 
  def read(self, iprot):
19682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19684 
      return
19685 
    iprot.readStructBegin()
19686 
    while True:
19687 
      (fname, ftype, fid) = iprot.readFieldBegin()
19688 
      if ftype == TType.STOP:
19689 
        break
19690 
      if fid == 1:
19691 
        if ftype == TType.STRUCT:
19692 
          self.ex = TransactionServiceException()
19693 
          self.ex.read(iprot)
19694 
        else:
19695 
          iprot.skip(ftype)
19696 
      else:
19697 
        iprot.skip(ftype)
19698 
      iprot.readFieldEnd()
19699 
    iprot.readStructEnd()
19700 
 
19701 
  def write(self, oprot):
19702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19704 
      return
19705 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19706 
    if self.ex is not None:
19707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19708 
      self.ex.write(oprot)
19709 
      oprot.writeFieldEnd()
19710 
    oprot.writeFieldStop()
19711 
    oprot.writeStructEnd()
19712 
 
19713 
  def validate(self):
19714 
    return
19715 
 
19716 
 
19717 
  def __repr__(self):
19718 
    L = ['%s=%r' % (key, value)
19719 
      for key, value in self.__dict__.iteritems()]
19720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19721 
 
19722 
  def __eq__(self, other):
19723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19724 
 
19725 
  def __ne__(self, other):
19726 
    return not (self == other)
4369 rajveer 19727 
 
19728 
class markOrdersAsTimeout_args:
19729 
  """
19730 
  Attributes:
19731 
   - vendorId
19732 
  """
19733 
 
19734 
  thrift_spec = (
19735 
    None, # 0
19736 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19737 
  )
19738 
 
19739 
  def __init__(self, vendorId=None,):
19740 
    self.vendorId = vendorId
19741 
 
19742 
  def read(self, iprot):
19743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19745 
      return
19746 
    iprot.readStructBegin()
19747 
    while True:
19748 
      (fname, ftype, fid) = iprot.readFieldBegin()
19749 
      if ftype == TType.STOP:
19750 
        break
19751 
      if fid == 1:
19752 
        if ftype == TType.I64:
19753 
          self.vendorId = iprot.readI64();
19754 
        else:
19755 
          iprot.skip(ftype)
19756 
      else:
19757 
        iprot.skip(ftype)
19758 
      iprot.readFieldEnd()
19759 
    iprot.readStructEnd()
19760 
 
19761 
  def write(self, oprot):
19762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19764 
      return
19765 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19766 
    if self.vendorId is not None:
19767 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19768 
      oprot.writeI64(self.vendorId)
19769 
      oprot.writeFieldEnd()
19770 
    oprot.writeFieldStop()
19771 
    oprot.writeStructEnd()
19772 
 
19773 
  def validate(self):
19774 
    return
19775 
 
19776 
 
19777 
  def __repr__(self):
19778 
    L = ['%s=%r' % (key, value)
19779 
      for key, value in self.__dict__.iteritems()]
19780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19781 
 
19782 
  def __eq__(self, other):
19783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19784 
 
19785 
  def __ne__(self, other):
19786 
    return not (self == other)
19787 
 
19788 
class markOrdersAsTimeout_result:
19789 
  """
19790 
  Attributes:
19791 
   - success
19792 
   - ex
19793 
  """
19794 
 
19795 
  thrift_spec = (
19796 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19798 
  )
19799 
 
19800 
  def __init__(self, success=None, ex=None,):
19801 
    self.success = success
19802 
    self.ex = ex
19803 
 
19804 
  def read(self, iprot):
19805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19807 
      return
19808 
    iprot.readStructBegin()
19809 
    while True:
19810 
      (fname, ftype, fid) = iprot.readFieldBegin()
19811 
      if ftype == TType.STOP:
19812 
        break
19813 
      if fid == 0:
19814 
        if ftype == TType.MAP:
19815 
          self.success = {}
5481 phani.kuma 19816 
          (_ktype445, _vtype446, _size444 ) = iprot.readMapBegin()
19817 
          for _i448 in xrange(_size444):
19818 
            _key449 = iprot.readI32();
19819 
            _val450 = TimeoutSummary()
19820 
            _val450.read(iprot)
19821 
            self.success[_key449] = _val450
4369 rajveer 19822 
          iprot.readMapEnd()
19823 
        else:
19824 
          iprot.skip(ftype)
19825 
      elif fid == 1:
19826 
        if ftype == TType.STRUCT:
19827 
          self.ex = TransactionServiceException()
19828 
          self.ex.read(iprot)
19829 
        else:
19830 
          iprot.skip(ftype)
19831 
      else:
19832 
        iprot.skip(ftype)
19833 
      iprot.readFieldEnd()
19834 
    iprot.readStructEnd()
19835 
 
19836 
  def write(self, oprot):
19837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19839 
      return
19840 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19841 
    if self.success is not None:
19842 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19843 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5481 phani.kuma 19844 
      for kiter451,viter452 in self.success.items():
19845 
        oprot.writeI32(kiter451)
19846 
        viter452.write(oprot)
4369 rajveer 19847 
      oprot.writeMapEnd()
19848 
      oprot.writeFieldEnd()
19849 
    if self.ex is not None:
19850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19851 
      self.ex.write(oprot)
19852 
      oprot.writeFieldEnd()
19853 
    oprot.writeFieldStop()
19854 
    oprot.writeStructEnd()
19855 
 
19856 
  def validate(self):
19857 
    return
19858 
 
19859 
 
19860 
  def __repr__(self):
19861 
    L = ['%s=%r' % (key, value)
19862 
      for key, value in self.__dict__.iteritems()]
19863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19864 
 
19865 
  def __eq__(self, other):
19866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19867 
 
19868 
  def __ne__(self, other):
19869 
    return not (self == other)
4386 anupam.sin 19870 
 
4662 rajveer 19871 
class markOrderAsLostInTransit_args:
19872 
  """
19873 
  Attributes:
19874 
   - orderId
19875 
  """
19876 
 
19877 
  thrift_spec = (
19878 
    None, # 0
19879 
    (1, TType.I64, 'orderId', None, None, ), # 1
19880 
  )
19881 
 
19882 
  def __init__(self, orderId=None,):
19883 
    self.orderId = orderId
19884 
 
19885 
  def read(self, iprot):
19886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19888 
      return
19889 
    iprot.readStructBegin()
19890 
    while True:
19891 
      (fname, ftype, fid) = iprot.readFieldBegin()
19892 
      if ftype == TType.STOP:
19893 
        break
19894 
      if fid == 1:
19895 
        if ftype == TType.I64:
19896 
          self.orderId = iprot.readI64();
19897 
        else:
19898 
          iprot.skip(ftype)
19899 
      else:
19900 
        iprot.skip(ftype)
19901 
      iprot.readFieldEnd()
19902 
    iprot.readStructEnd()
19903 
 
19904 
  def write(self, oprot):
19905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19907 
      return
19908 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19909 
    if self.orderId is not None:
19910 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19911 
      oprot.writeI64(self.orderId)
19912 
      oprot.writeFieldEnd()
19913 
    oprot.writeFieldStop()
19914 
    oprot.writeStructEnd()
19915 
 
19916 
  def validate(self):
19917 
    return
19918 
 
19919 
 
19920 
  def __repr__(self):
19921 
    L = ['%s=%r' % (key, value)
19922 
      for key, value in self.__dict__.iteritems()]
19923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19924 
 
19925 
  def __eq__(self, other):
19926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19927 
 
19928 
  def __ne__(self, other):
19929 
    return not (self == other)
19930 
 
19931 
class markOrderAsLostInTransit_result:
19932 
  """
19933 
  Attributes:
19934 
   - success
19935 
   - ex
19936 
  """
19937 
 
19938 
  thrift_spec = (
19939 
    (0, TType.BOOL, 'success', None, None, ), # 0
19940 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19941 
  )
19942 
 
19943 
  def __init__(self, success=None, ex=None,):
19944 
    self.success = success
19945 
    self.ex = ex
19946 
 
19947 
  def read(self, iprot):
19948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19950 
      return
19951 
    iprot.readStructBegin()
19952 
    while True:
19953 
      (fname, ftype, fid) = iprot.readFieldBegin()
19954 
      if ftype == TType.STOP:
19955 
        break
19956 
      if fid == 0:
19957 
        if ftype == TType.BOOL:
19958 
          self.success = iprot.readBool();
19959 
        else:
19960 
          iprot.skip(ftype)
19961 
      elif fid == 1:
19962 
        if ftype == TType.STRUCT:
19963 
          self.ex = TransactionServiceException()
19964 
          self.ex.read(iprot)
19965 
        else:
19966 
          iprot.skip(ftype)
19967 
      else:
19968 
        iprot.skip(ftype)
19969 
      iprot.readFieldEnd()
19970 
    iprot.readStructEnd()
19971 
 
19972 
  def write(self, oprot):
19973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19975 
      return
19976 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19977 
    if self.success is not None:
19978 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19979 
      oprot.writeBool(self.success)
19980 
      oprot.writeFieldEnd()
19981 
    if self.ex is not None:
19982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19983 
      self.ex.write(oprot)
19984 
      oprot.writeFieldEnd()
19985 
    oprot.writeFieldStop()
19986 
    oprot.writeStructEnd()
19987 
 
19988 
  def validate(self):
19989 
    return
19990 
 
19991 
 
19992 
  def __repr__(self):
19993 
    L = ['%s=%r' % (key, value)
19994 
      for key, value in self.__dict__.iteritems()]
19995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19996 
 
19997 
  def __eq__(self, other):
19998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19999 
 
20000 
  def __ne__(self, other):
20001 
    return not (self == other)
20002 
 
4386 anupam.sin 20003 
class getOrderForAwb_args:
20004 
  """
20005 
  Attributes:
20006 
   - awb
20007 
  """
20008 
 
20009 
  thrift_spec = (
20010 
    None, # 0
20011 
    (1, TType.STRING, 'awb', None, None, ), # 1
20012 
  )
20013 
 
20014 
  def __init__(self, awb=None,):
20015 
    self.awb = awb
20016 
 
20017 
  def read(self, iprot):
20018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20020 
      return
20021 
    iprot.readStructBegin()
20022 
    while True:
20023 
      (fname, ftype, fid) = iprot.readFieldBegin()
20024 
      if ftype == TType.STOP:
20025 
        break
20026 
      if fid == 1:
20027 
        if ftype == TType.STRING:
20028 
          self.awb = iprot.readString();
20029 
        else:
20030 
          iprot.skip(ftype)
20031 
      else:
20032 
        iprot.skip(ftype)
20033 
      iprot.readFieldEnd()
20034 
    iprot.readStructEnd()
20035 
 
20036 
  def write(self, oprot):
20037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20039 
      return
20040 
    oprot.writeStructBegin('getOrderForAwb_args')
20041 
    if self.awb is not None:
20042 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20043 
      oprot.writeString(self.awb)
20044 
      oprot.writeFieldEnd()
20045 
    oprot.writeFieldStop()
20046 
    oprot.writeStructEnd()
20047 
 
20048 
  def validate(self):
20049 
    return
20050 
 
20051 
 
20052 
  def __repr__(self):
20053 
    L = ['%s=%r' % (key, value)
20054 
      for key, value in self.__dict__.iteritems()]
20055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20056 
 
20057 
  def __eq__(self, other):
20058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20059 
 
20060 
  def __ne__(self, other):
20061 
    return not (self == other)
20062 
 
20063 
class getOrderForAwb_result:
20064 
  """
20065 
  Attributes:
20066 
   - success
20067 
   - ex
20068 
  """
20069 
 
20070 
  thrift_spec = (
20071 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20073 
  )
20074 
 
20075 
  def __init__(self, success=None, ex=None,):
20076 
    self.success = success
20077 
    self.ex = ex
20078 
 
20079 
  def read(self, iprot):
20080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20082 
      return
20083 
    iprot.readStructBegin()
20084 
    while True:
20085 
      (fname, ftype, fid) = iprot.readFieldBegin()
20086 
      if ftype == TType.STOP:
20087 
        break
20088 
      if fid == 0:
20089 
        if ftype == TType.STRUCT:
20090 
          self.success = Order()
20091 
          self.success.read(iprot)
20092 
        else:
20093 
          iprot.skip(ftype)
20094 
      elif fid == 1:
20095 
        if ftype == TType.STRUCT:
20096 
          self.ex = TransactionServiceException()
20097 
          self.ex.read(iprot)
20098 
        else:
20099 
          iprot.skip(ftype)
20100 
      else:
20101 
        iprot.skip(ftype)
20102 
      iprot.readFieldEnd()
20103 
    iprot.readStructEnd()
20104 
 
20105 
  def write(self, oprot):
20106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20108 
      return
20109 
    oprot.writeStructBegin('getOrderForAwb_result')
20110 
    if self.success is not None:
20111 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20112 
      self.success.write(oprot)
20113 
      oprot.writeFieldEnd()
20114 
    if self.ex is not None:
20115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20116 
      self.ex.write(oprot)
20117 
      oprot.writeFieldEnd()
20118 
    oprot.writeFieldStop()
20119 
    oprot.writeStructEnd()
20120 
 
20121 
  def validate(self):
20122 
    return
20123 
 
20124 
 
20125 
  def __repr__(self):
20126 
    L = ['%s=%r' % (key, value)
20127 
      for key, value in self.__dict__.iteritems()]
20128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20129 
 
20130 
  def __eq__(self, other):
20131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20132 
 
20133 
  def __ne__(self, other):
20134 
    return not (self == other)
4506 phani.kuma 20135 
 
20136 
class getOrdersForProviderForStatus_args:
20137 
  """
20138 
  Attributes:
20139 
   - logistics_provider_id
4910 phani.kuma 20140 
   - order_status_list
4506 phani.kuma 20141 
  """
20142 
 
20143 
  thrift_spec = (
20144 
    None, # 0
20145 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 20146 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 20147 
  )
20148 
 
4910 phani.kuma 20149 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 20150 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 20151 
    self.order_status_list = order_status_list
4506 phani.kuma 20152 
 
20153 
  def read(self, iprot):
20154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20156 
      return
20157 
    iprot.readStructBegin()
20158 
    while True:
20159 
      (fname, ftype, fid) = iprot.readFieldBegin()
20160 
      if ftype == TType.STOP:
20161 
        break
20162 
      if fid == 1:
20163 
        if ftype == TType.I64:
20164 
          self.logistics_provider_id = iprot.readI64();
20165 
        else:
20166 
          iprot.skip(ftype)
20167 
      elif fid == 2:
4910 phani.kuma 20168 
        if ftype == TType.LIST:
20169 
          self.order_status_list = []
5481 phani.kuma 20170 
          (_etype456, _size453) = iprot.readListBegin()
20171 
          for _i457 in xrange(_size453):
20172 
            _elem458 = iprot.readI32();
20173 
            self.order_status_list.append(_elem458)
4910 phani.kuma 20174 
          iprot.readListEnd()
4506 phani.kuma 20175 
        else:
20176 
          iprot.skip(ftype)
20177 
      else:
20178 
        iprot.skip(ftype)
20179 
      iprot.readFieldEnd()
20180 
    iprot.readStructEnd()
20181 
 
20182 
  def write(self, oprot):
20183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20185 
      return
20186 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
20187 
    if self.logistics_provider_id is not None:
20188 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
20189 
      oprot.writeI64(self.logistics_provider_id)
20190 
      oprot.writeFieldEnd()
4910 phani.kuma 20191 
    if self.order_status_list is not None:
20192 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
20193 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5481 phani.kuma 20194 
      for iter459 in self.order_status_list:
20195 
        oprot.writeI32(iter459)
4910 phani.kuma 20196 
      oprot.writeListEnd()
4506 phani.kuma 20197 
      oprot.writeFieldEnd()
20198 
    oprot.writeFieldStop()
20199 
    oprot.writeStructEnd()
20200 
 
20201 
  def validate(self):
20202 
    return
20203 
 
20204 
 
20205 
  def __repr__(self):
20206 
    L = ['%s=%r' % (key, value)
20207 
      for key, value in self.__dict__.iteritems()]
20208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20209 
 
20210 
  def __eq__(self, other):
20211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20212 
 
20213 
  def __ne__(self, other):
20214 
    return not (self == other)
20215 
 
20216 
class getOrdersForProviderForStatus_result:
20217 
  """
20218 
  Attributes:
20219 
   - success
20220 
   - ex
20221 
  """
20222 
 
20223 
  thrift_spec = (
20224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20226 
  )
20227 
 
20228 
  def __init__(self, success=None, ex=None,):
20229 
    self.success = success
20230 
    self.ex = ex
20231 
 
20232 
  def read(self, iprot):
20233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20235 
      return
20236 
    iprot.readStructBegin()
20237 
    while True:
20238 
      (fname, ftype, fid) = iprot.readFieldBegin()
20239 
      if ftype == TType.STOP:
20240 
        break
20241 
      if fid == 0:
20242 
        if ftype == TType.LIST:
20243 
          self.success = []
5481 phani.kuma 20244 
          (_etype463, _size460) = iprot.readListBegin()
20245 
          for _i464 in xrange(_size460):
20246 
            _elem465 = Order()
20247 
            _elem465.read(iprot)
20248 
            self.success.append(_elem465)
4506 phani.kuma 20249 
          iprot.readListEnd()
20250 
        else:
20251 
          iprot.skip(ftype)
20252 
      elif fid == 1:
20253 
        if ftype == TType.STRUCT:
20254 
          self.ex = TransactionServiceException()
20255 
          self.ex.read(iprot)
20256 
        else:
20257 
          iprot.skip(ftype)
20258 
      else:
20259 
        iprot.skip(ftype)
20260 
      iprot.readFieldEnd()
20261 
    iprot.readStructEnd()
20262 
 
20263 
  def write(self, oprot):
20264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20266 
      return
20267 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
20268 
    if self.success is not None:
20269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20271 
      for iter466 in self.success:
20272 
        iter466.write(oprot)
4506 phani.kuma 20273 
      oprot.writeListEnd()
20274 
      oprot.writeFieldEnd()
20275 
    if self.ex is not None:
20276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20277 
      self.ex.write(oprot)
20278 
      oprot.writeFieldEnd()
20279 
    oprot.writeFieldStop()
20280 
    oprot.writeStructEnd()
20281 
 
20282 
  def validate(self):
20283 
    return
20284 
 
20285 
 
20286 
  def __repr__(self):
20287 
    L = ['%s=%r' % (key, value)
20288 
      for key, value in self.__dict__.iteritems()]
20289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20290 
 
20291 
  def __eq__(self, other):
20292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20293 
 
20294 
  def __ne__(self, other):
20295 
    return not (self == other)
4600 varun.gupt 20296 
 
20297 
class getBilledOrdersForVendor_args:
20298 
  """
20299 
  Attributes:
20300 
   - vendorId
20301 
   - billingDateFrom
20302 
   - billingDateTo
20303 
  """
20304 
 
20305 
  thrift_spec = (
20306 
    None, # 0
20307 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20308 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20309 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20310 
  )
20311 
 
20312 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20313 
    self.vendorId = vendorId
20314 
    self.billingDateFrom = billingDateFrom
20315 
    self.billingDateTo = billingDateTo
20316 
 
20317 
  def read(self, iprot):
20318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20320 
      return
20321 
    iprot.readStructBegin()
20322 
    while True:
20323 
      (fname, ftype, fid) = iprot.readFieldBegin()
20324 
      if ftype == TType.STOP:
20325 
        break
20326 
      if fid == 1:
20327 
        if ftype == TType.I64:
20328 
          self.vendorId = iprot.readI64();
20329 
        else:
20330 
          iprot.skip(ftype)
20331 
      elif fid == 2:
20332 
        if ftype == TType.I64:
20333 
          self.billingDateFrom = iprot.readI64();
20334 
        else:
20335 
          iprot.skip(ftype)
20336 
      elif fid == 3:
20337 
        if ftype == TType.I64:
20338 
          self.billingDateTo = iprot.readI64();
20339 
        else:
20340 
          iprot.skip(ftype)
20341 
      else:
20342 
        iprot.skip(ftype)
20343 
      iprot.readFieldEnd()
20344 
    iprot.readStructEnd()
20345 
 
20346 
  def write(self, oprot):
20347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20349 
      return
20350 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20351 
    if self.vendorId is not None:
20352 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20353 
      oprot.writeI64(self.vendorId)
20354 
      oprot.writeFieldEnd()
20355 
    if self.billingDateFrom is not None:
20356 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20357 
      oprot.writeI64(self.billingDateFrom)
20358 
      oprot.writeFieldEnd()
20359 
    if self.billingDateTo is not None:
20360 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20361 
      oprot.writeI64(self.billingDateTo)
20362 
      oprot.writeFieldEnd()
20363 
    oprot.writeFieldStop()
20364 
    oprot.writeStructEnd()
20365 
 
20366 
  def validate(self):
20367 
    return
20368 
 
20369 
 
20370 
  def __repr__(self):
20371 
    L = ['%s=%r' % (key, value)
20372 
      for key, value in self.__dict__.iteritems()]
20373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20374 
 
20375 
  def __eq__(self, other):
20376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20377 
 
20378 
  def __ne__(self, other):
20379 
    return not (self == other)
20380 
 
20381 
class getBilledOrdersForVendor_result:
20382 
  """
20383 
  Attributes:
20384 
   - success
20385 
   - ex
20386 
  """
20387 
 
20388 
  thrift_spec = (
20389 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20391 
  )
20392 
 
20393 
  def __init__(self, success=None, ex=None,):
20394 
    self.success = success
20395 
    self.ex = ex
20396 
 
20397 
  def read(self, iprot):
20398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20400 
      return
20401 
    iprot.readStructBegin()
20402 
    while True:
20403 
      (fname, ftype, fid) = iprot.readFieldBegin()
20404 
      if ftype == TType.STOP:
20405 
        break
20406 
      if fid == 0:
20407 
        if ftype == TType.LIST:
20408 
          self.success = []
5481 phani.kuma 20409 
          (_etype470, _size467) = iprot.readListBegin()
20410 
          for _i471 in xrange(_size467):
20411 
            _elem472 = Order()
20412 
            _elem472.read(iprot)
20413 
            self.success.append(_elem472)
4600 varun.gupt 20414 
          iprot.readListEnd()
20415 
        else:
20416 
          iprot.skip(ftype)
20417 
      elif fid == 1:
20418 
        if ftype == TType.STRUCT:
20419 
          self.ex = TransactionServiceException()
20420 
          self.ex.read(iprot)
20421 
        else:
20422 
          iprot.skip(ftype)
20423 
      else:
20424 
        iprot.skip(ftype)
20425 
      iprot.readFieldEnd()
20426 
    iprot.readStructEnd()
20427 
 
20428 
  def write(self, oprot):
20429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20431 
      return
20432 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20433 
    if self.success is not None:
20434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20436 
      for iter473 in self.success:
20437 
        iter473.write(oprot)
4600 varun.gupt 20438 
      oprot.writeListEnd()
20439 
      oprot.writeFieldEnd()
20440 
    if self.ex is not None:
20441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20442 
      self.ex.write(oprot)
20443 
      oprot.writeFieldEnd()
20444 
    oprot.writeFieldStop()
20445 
    oprot.writeStructEnd()
20446 
 
20447 
  def validate(self):
20448 
    return
20449 
 
20450 
 
20451 
  def __repr__(self):
20452 
    L = ['%s=%r' % (key, value)
20453 
      for key, value in self.__dict__.iteritems()]
20454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20455 
 
20456 
  def __eq__(self, other):
20457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20458 
 
20459 
  def __ne__(self, other):
20460 
    return not (self == other)
20461 
 
4607 rajveer 20462 
class getSlippedSippingDateOrders_args:
20463 
 
20464 
  thrift_spec = (
20465 
  )
20466 
 
20467 
  def read(self, iprot):
20468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20470 
      return
20471 
    iprot.readStructBegin()
20472 
    while True:
20473 
      (fname, ftype, fid) = iprot.readFieldBegin()
20474 
      if ftype == TType.STOP:
20475 
        break
20476 
      else:
20477 
        iprot.skip(ftype)
20478 
      iprot.readFieldEnd()
20479 
    iprot.readStructEnd()
20480 
 
20481 
  def write(self, oprot):
20482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20484 
      return
20485 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20486 
    oprot.writeFieldStop()
20487 
    oprot.writeStructEnd()
20488 
 
20489 
  def validate(self):
20490 
    return
20491 
 
20492 
 
20493 
  def __repr__(self):
20494 
    L = ['%s=%r' % (key, value)
20495 
      for key, value in self.__dict__.iteritems()]
20496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20497 
 
20498 
  def __eq__(self, other):
20499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20500 
 
20501 
  def __ne__(self, other):
20502 
    return not (self == other)
20503 
 
20504 
class getSlippedSippingDateOrders_result:
20505 
  """
20506 
  Attributes:
20507 
   - success
20508 
   - ex
20509 
  """
20510 
 
20511 
  thrift_spec = (
20512 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20514 
  )
20515 
 
20516 
  def __init__(self, success=None, ex=None,):
20517 
    self.success = success
20518 
    self.ex = ex
20519 
 
20520 
  def read(self, iprot):
20521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20523 
      return
20524 
    iprot.readStructBegin()
20525 
    while True:
20526 
      (fname, ftype, fid) = iprot.readFieldBegin()
20527 
      if ftype == TType.STOP:
20528 
        break
20529 
      if fid == 0:
20530 
        if ftype == TType.LIST:
20531 
          self.success = []
5481 phani.kuma 20532 
          (_etype477, _size474) = iprot.readListBegin()
20533 
          for _i478 in xrange(_size474):
20534 
            _elem479 = Order()
20535 
            _elem479.read(iprot)
20536 
            self.success.append(_elem479)
4607 rajveer 20537 
          iprot.readListEnd()
20538 
        else:
20539 
          iprot.skip(ftype)
20540 
      elif fid == 1:
20541 
        if ftype == TType.STRUCT:
20542 
          self.ex = TransactionServiceException()
20543 
          self.ex.read(iprot)
20544 
        else:
20545 
          iprot.skip(ftype)
20546 
      else:
20547 
        iprot.skip(ftype)
20548 
      iprot.readFieldEnd()
20549 
    iprot.readStructEnd()
20550 
 
20551 
  def write(self, oprot):
20552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20554 
      return
20555 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20556 
    if self.success is not None:
20557 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20558 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20559 
      for iter480 in self.success:
20560 
        iter480.write(oprot)
4607 rajveer 20561 
      oprot.writeListEnd()
20562 
      oprot.writeFieldEnd()
20563 
    if self.ex is not None:
20564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20565 
      self.ex.write(oprot)
20566 
      oprot.writeFieldEnd()
20567 
    oprot.writeFieldStop()
20568 
    oprot.writeStructEnd()
20569 
 
20570 
  def validate(self):
20571 
    return
20572 
 
20573 
 
20574 
  def __repr__(self):
20575 
    L = ['%s=%r' % (key, value)
20576 
      for key, value in self.__dict__.iteritems()]
20577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20578 
 
20579 
  def __eq__(self, other):
20580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20581 
 
20582 
  def __ne__(self, other):
20583 
    return not (self == other)
20584 
 
4709 rajveer 20585 
class getCancelledOrders_args:
20586 
  """
20587 
  Attributes:
20588 
   - cancelDateFrom
20589 
   - cancelDateTo
20590 
  """
20591 
 
20592 
  thrift_spec = (
20593 
    None, # 0
20594 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20595 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20596 
  )
20597 
 
20598 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20599 
    self.cancelDateFrom = cancelDateFrom
20600 
    self.cancelDateTo = cancelDateTo
20601 
 
20602 
  def read(self, iprot):
20603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20605 
      return
20606 
    iprot.readStructBegin()
20607 
    while True:
20608 
      (fname, ftype, fid) = iprot.readFieldBegin()
20609 
      if ftype == TType.STOP:
20610 
        break
20611 
      if fid == 1:
20612 
        if ftype == TType.I64:
20613 
          self.cancelDateFrom = iprot.readI64();
20614 
        else:
20615 
          iprot.skip(ftype)
20616 
      elif fid == 2:
20617 
        if ftype == TType.I64:
20618 
          self.cancelDateTo = iprot.readI64();
20619 
        else:
20620 
          iprot.skip(ftype)
20621 
      else:
20622 
        iprot.skip(ftype)
20623 
      iprot.readFieldEnd()
20624 
    iprot.readStructEnd()
20625 
 
20626 
  def write(self, oprot):
20627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20629 
      return
20630 
    oprot.writeStructBegin('getCancelledOrders_args')
20631 
    if self.cancelDateFrom is not None:
20632 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20633 
      oprot.writeI64(self.cancelDateFrom)
20634 
      oprot.writeFieldEnd()
20635 
    if self.cancelDateTo is not None:
20636 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20637 
      oprot.writeI64(self.cancelDateTo)
20638 
      oprot.writeFieldEnd()
20639 
    oprot.writeFieldStop()
20640 
    oprot.writeStructEnd()
20641 
 
20642 
  def validate(self):
20643 
    return
20644 
 
20645 
 
20646 
  def __repr__(self):
20647 
    L = ['%s=%r' % (key, value)
20648 
      for key, value in self.__dict__.iteritems()]
20649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20650 
 
20651 
  def __eq__(self, other):
20652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20653 
 
20654 
  def __ne__(self, other):
20655 
    return not (self == other)
20656 
 
20657 
class getCancelledOrders_result:
20658 
  """
20659 
  Attributes:
20660 
   - success
20661 
   - ex
20662 
  """
20663 
 
20664 
  thrift_spec = (
20665 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20667 
  )
20668 
 
20669 
  def __init__(self, success=None, ex=None,):
20670 
    self.success = success
20671 
    self.ex = ex
20672 
 
20673 
  def read(self, iprot):
20674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20676 
      return
20677 
    iprot.readStructBegin()
20678 
    while True:
20679 
      (fname, ftype, fid) = iprot.readFieldBegin()
20680 
      if ftype == TType.STOP:
20681 
        break
20682 
      if fid == 0:
20683 
        if ftype == TType.LIST:
20684 
          self.success = []
5481 phani.kuma 20685 
          (_etype484, _size481) = iprot.readListBegin()
20686 
          for _i485 in xrange(_size481):
20687 
            _elem486 = Order()
20688 
            _elem486.read(iprot)
20689 
            self.success.append(_elem486)
4709 rajveer 20690 
          iprot.readListEnd()
20691 
        else:
20692 
          iprot.skip(ftype)
20693 
      elif fid == 1:
20694 
        if ftype == TType.STRUCT:
20695 
          self.ex = TransactionServiceException()
20696 
          self.ex.read(iprot)
20697 
        else:
20698 
          iprot.skip(ftype)
20699 
      else:
20700 
        iprot.skip(ftype)
20701 
      iprot.readFieldEnd()
20702 
    iprot.readStructEnd()
20703 
 
20704 
  def write(self, oprot):
20705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20707 
      return
20708 
    oprot.writeStructBegin('getCancelledOrders_result')
20709 
    if self.success is not None:
20710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20711 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 20712 
      for iter487 in self.success:
20713 
        iter487.write(oprot)
4709 rajveer 20714 
      oprot.writeListEnd()
20715 
      oprot.writeFieldEnd()
20716 
    if self.ex is not None:
20717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20718 
      self.ex.write(oprot)
20719 
      oprot.writeFieldEnd()
20720 
    oprot.writeFieldStop()
20721 
    oprot.writeStructEnd()
20722 
 
20723 
  def validate(self):
20724 
    return
20725 
 
20726 
 
20727 
  def __repr__(self):
20728 
    L = ['%s=%r' % (key, value)
20729 
      for key, value in self.__dict__.iteritems()]
20730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20731 
 
20732 
  def __eq__(self, other):
20733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20734 
 
20735 
  def __ne__(self, other):
20736 
    return not (self == other)
20737 
 
4600 varun.gupt 20738 
class saveBluedartSettlements_args:
20739 
  """
20740 
  Attributes:
20741 
   - mapAWBAndAmount
20742 
  """
20743 
 
20744 
  thrift_spec = (
20745 
    None, # 0
20746 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20747 
  )
20748 
 
20749 
  def __init__(self, mapAWBAndAmount=None,):
20750 
    self.mapAWBAndAmount = mapAWBAndAmount
20751 
 
20752 
  def read(self, iprot):
20753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20755 
      return
20756 
    iprot.readStructBegin()
20757 
    while True:
20758 
      (fname, ftype, fid) = iprot.readFieldBegin()
20759 
      if ftype == TType.STOP:
20760 
        break
20761 
      if fid == 1:
20762 
        if ftype == TType.MAP:
20763 
          self.mapAWBAndAmount = {}
5481 phani.kuma 20764 
          (_ktype489, _vtype490, _size488 ) = iprot.readMapBegin()
20765 
          for _i492 in xrange(_size488):
20766 
            _key493 = iprot.readI64();
20767 
            _val494 = iprot.readDouble();
20768 
            self.mapAWBAndAmount[_key493] = _val494
4600 varun.gupt 20769 
          iprot.readMapEnd()
20770 
        else:
20771 
          iprot.skip(ftype)
20772 
      else:
20773 
        iprot.skip(ftype)
20774 
      iprot.readFieldEnd()
20775 
    iprot.readStructEnd()
20776 
 
20777 
  def write(self, oprot):
20778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20780 
      return
20781 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20782 
    if self.mapAWBAndAmount is not None:
20783 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20784 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5481 phani.kuma 20785 
      for kiter495,viter496 in self.mapAWBAndAmount.items():
20786 
        oprot.writeI64(kiter495)
20787 
        oprot.writeDouble(viter496)
4600 varun.gupt 20788 
      oprot.writeMapEnd()
20789 
      oprot.writeFieldEnd()
20790 
    oprot.writeFieldStop()
20791 
    oprot.writeStructEnd()
20792 
 
20793 
  def validate(self):
20794 
    return
20795 
 
20796 
 
20797 
  def __repr__(self):
20798 
    L = ['%s=%r' % (key, value)
20799 
      for key, value in self.__dict__.iteritems()]
20800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20801 
 
20802 
  def __eq__(self, other):
20803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20804 
 
20805 
  def __ne__(self, other):
20806 
    return not (self == other)
20807 
 
20808 
class saveBluedartSettlements_result:
20809 
  """
20810 
  Attributes:
20811 
   - ex
20812 
  """
20813 
 
20814 
  thrift_spec = (
20815 
    None, # 0
20816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20817 
  )
20818 
 
20819 
  def __init__(self, ex=None,):
20820 
    self.ex = ex
20821 
 
20822 
  def read(self, iprot):
20823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20825 
      return
20826 
    iprot.readStructBegin()
20827 
    while True:
20828 
      (fname, ftype, fid) = iprot.readFieldBegin()
20829 
      if ftype == TType.STOP:
20830 
        break
20831 
      if fid == 1:
20832 
        if ftype == TType.STRUCT:
20833 
          self.ex = TransactionServiceException()
20834 
          self.ex.read(iprot)
20835 
        else:
20836 
          iprot.skip(ftype)
20837 
      else:
20838 
        iprot.skip(ftype)
20839 
      iprot.readFieldEnd()
20840 
    iprot.readStructEnd()
20841 
 
20842 
  def write(self, oprot):
20843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20845 
      return
20846 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20847 
    if self.ex is not None:
20848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20849 
      self.ex.write(oprot)
20850 
      oprot.writeFieldEnd()
20851 
    oprot.writeFieldStop()
20852 
    oprot.writeStructEnd()
20853 
 
20854 
  def validate(self):
20855 
    return
20856 
 
20857 
 
20858 
  def __repr__(self):
20859 
    L = ['%s=%r' % (key, value)
20860 
      for key, value in self.__dict__.iteritems()]
20861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20862 
 
20863 
  def __eq__(self, other):
20864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20865 
 
20866 
  def __ne__(self, other):
20867 
    return not (self == other)
20868 
 
20869 
class savePaymentSettlements_args:
20870 
  """
20871 
  Attributes:
20872 
   - settlementDate
20873 
   - paymentGatewayId
4905 varun.gupt 20874 
   - referenceId
4600 varun.gupt 20875 
   - serviceTax
20876 
   - otherCharges
20877 
   - netCollection
20878 
  """
20879 
 
20880 
  thrift_spec = (
20881 
    None, # 0
20882 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20883 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20884 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20885 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20886 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20887 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20888 
  )
20889 
 
4905 varun.gupt 20890 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20891 
    self.settlementDate = settlementDate
20892 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20893 
    self.referenceId = referenceId
4600 varun.gupt 20894 
    self.serviceTax = serviceTax
20895 
    self.otherCharges = otherCharges
20896 
    self.netCollection = netCollection
20897 
 
20898 
  def read(self, iprot):
20899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20901 
      return
20902 
    iprot.readStructBegin()
20903 
    while True:
20904 
      (fname, ftype, fid) = iprot.readFieldBegin()
20905 
      if ftype == TType.STOP:
20906 
        break
20907 
      if fid == 1:
20908 
        if ftype == TType.I64:
20909 
          self.settlementDate = iprot.readI64();
20910 
        else:
20911 
          iprot.skip(ftype)
20912 
      elif fid == 2:
20913 
        if ftype == TType.I64:
20914 
          self.paymentGatewayId = iprot.readI64();
20915 
        else:
20916 
          iprot.skip(ftype)
20917 
      elif fid == 3:
20918 
        if ftype == TType.I64:
4905 varun.gupt 20919 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20920 
        else:
20921 
          iprot.skip(ftype)
20922 
      elif fid == 4:
20923 
        if ftype == TType.DOUBLE:
20924 
          self.serviceTax = iprot.readDouble();
20925 
        else:
20926 
          iprot.skip(ftype)
20927 
      elif fid == 5:
20928 
        if ftype == TType.DOUBLE:
20929 
          self.otherCharges = iprot.readDouble();
20930 
        else:
20931 
          iprot.skip(ftype)
20932 
      elif fid == 6:
20933 
        if ftype == TType.DOUBLE:
20934 
          self.netCollection = iprot.readDouble();
20935 
        else:
20936 
          iprot.skip(ftype)
20937 
      else:
20938 
        iprot.skip(ftype)
20939 
      iprot.readFieldEnd()
20940 
    iprot.readStructEnd()
20941 
 
20942 
  def write(self, oprot):
20943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20945 
      return
20946 
    oprot.writeStructBegin('savePaymentSettlements_args')
20947 
    if self.settlementDate is not None:
20948 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20949 
      oprot.writeI64(self.settlementDate)
20950 
      oprot.writeFieldEnd()
20951 
    if self.paymentGatewayId is not None:
20952 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20953 
      oprot.writeI64(self.paymentGatewayId)
20954 
      oprot.writeFieldEnd()
4905 varun.gupt 20955 
    if self.referenceId is not None:
20956 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20957 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20958 
      oprot.writeFieldEnd()
20959 
    if self.serviceTax is not None:
20960 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20961 
      oprot.writeDouble(self.serviceTax)
20962 
      oprot.writeFieldEnd()
20963 
    if self.otherCharges is not None:
20964 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20965 
      oprot.writeDouble(self.otherCharges)
20966 
      oprot.writeFieldEnd()
20967 
    if self.netCollection is not None:
20968 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20969 
      oprot.writeDouble(self.netCollection)
20970 
      oprot.writeFieldEnd()
20971 
    oprot.writeFieldStop()
20972 
    oprot.writeStructEnd()
20973 
 
20974 
  def validate(self):
20975 
    return
20976 
 
20977 
 
20978 
  def __repr__(self):
20979 
    L = ['%s=%r' % (key, value)
20980 
      for key, value in self.__dict__.iteritems()]
20981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20982 
 
20983 
  def __eq__(self, other):
20984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20985 
 
20986 
  def __ne__(self, other):
20987 
    return not (self == other)
20988 
 
20989 
class savePaymentSettlements_result:
20990 
  """
20991 
  Attributes:
20992 
   - ex
20993 
  """
20994 
 
20995 
  thrift_spec = (
20996 
    None, # 0
20997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20998 
  )
20999 
 
21000 
  def __init__(self, ex=None,):
21001 
    self.ex = ex
21002 
 
21003 
  def read(self, iprot):
21004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21006 
      return
21007 
    iprot.readStructBegin()
21008 
    while True:
21009 
      (fname, ftype, fid) = iprot.readFieldBegin()
21010 
      if ftype == TType.STOP:
21011 
        break
21012 
      if fid == 1:
21013 
        if ftype == TType.STRUCT:
21014 
          self.ex = TransactionServiceException()
21015 
          self.ex.read(iprot)
21016 
        else:
21017 
          iprot.skip(ftype)
21018 
      else:
21019 
        iprot.skip(ftype)
21020 
      iprot.readFieldEnd()
21021 
    iprot.readStructEnd()
21022 
 
21023 
  def write(self, oprot):
21024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21026 
      return
21027 
    oprot.writeStructBegin('savePaymentSettlements_result')
21028 
    if self.ex is not None:
21029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21030 
      self.ex.write(oprot)
21031 
      oprot.writeFieldEnd()
21032 
    oprot.writeFieldStop()
21033 
    oprot.writeStructEnd()
21034 
 
21035 
  def validate(self):
21036 
    return
21037 
 
21038 
 
21039 
  def __repr__(self):
21040 
    L = ['%s=%r' % (key, value)
21041 
      for key, value in self.__dict__.iteritems()]
21042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21043 
 
21044 
  def __eq__(self, other):
21045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21046 
 
21047 
  def __ne__(self, other):
21048 
    return not (self == other)
21049 
 
21050 
class saveEBSSettlementSummary_args:
21051 
  """
21052 
  Attributes:
21053 
   - settlementId
21054 
   - settlementDate
21055 
   - transactionDateFrom
21056 
   - transactionDateTo
21057 
   - amount
21058 
  """
21059 
 
21060 
  thrift_spec = (
21061 
    None, # 0
21062 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21063 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21064 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21065 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21066 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21067 
  )
21068 
 
21069 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21070 
    self.settlementId = settlementId
21071 
    self.settlementDate = settlementDate
21072 
    self.transactionDateFrom = transactionDateFrom
21073 
    self.transactionDateTo = transactionDateTo
21074 
    self.amount = amount
21075 
 
21076 
  def read(self, iprot):
21077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21079 
      return
21080 
    iprot.readStructBegin()
21081 
    while True:
21082 
      (fname, ftype, fid) = iprot.readFieldBegin()
21083 
      if ftype == TType.STOP:
21084 
        break
21085 
      if fid == 1:
21086 
        if ftype == TType.I64:
21087 
          self.settlementId = iprot.readI64();
21088 
        else:
21089 
          iprot.skip(ftype)
21090 
      elif fid == 2:
21091 
        if ftype == TType.I64:
21092 
          self.settlementDate = iprot.readI64();
21093 
        else:
21094 
          iprot.skip(ftype)
21095 
      elif fid == 3:
21096 
        if ftype == TType.I64:
21097 
          self.transactionDateFrom = iprot.readI64();
21098 
        else:
21099 
          iprot.skip(ftype)
21100 
      elif fid == 4:
21101 
        if ftype == TType.I64:
21102 
          self.transactionDateTo = iprot.readI64();
21103 
        else:
21104 
          iprot.skip(ftype)
21105 
      elif fid == 5:
21106 
        if ftype == TType.DOUBLE:
21107 
          self.amount = iprot.readDouble();
21108 
        else:
21109 
          iprot.skip(ftype)
21110 
      else:
21111 
        iprot.skip(ftype)
21112 
      iprot.readFieldEnd()
21113 
    iprot.readStructEnd()
21114 
 
21115 
  def write(self, oprot):
21116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21118 
      return
21119 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21120 
    if self.settlementId is not None:
21121 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21122 
      oprot.writeI64(self.settlementId)
21123 
      oprot.writeFieldEnd()
21124 
    if self.settlementDate is not None:
21125 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21126 
      oprot.writeI64(self.settlementDate)
21127 
      oprot.writeFieldEnd()
21128 
    if self.transactionDateFrom is not None:
21129 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21130 
      oprot.writeI64(self.transactionDateFrom)
21131 
      oprot.writeFieldEnd()
21132 
    if self.transactionDateTo is not None:
21133 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
21134 
      oprot.writeI64(self.transactionDateTo)
21135 
      oprot.writeFieldEnd()
21136 
    if self.amount is not None:
21137 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
21138 
      oprot.writeDouble(self.amount)
21139 
      oprot.writeFieldEnd()
21140 
    oprot.writeFieldStop()
21141 
    oprot.writeStructEnd()
21142 
 
21143 
  def validate(self):
21144 
    return
21145 
 
21146 
 
21147 
  def __repr__(self):
21148 
    L = ['%s=%r' % (key, value)
21149 
      for key, value in self.__dict__.iteritems()]
21150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21151 
 
21152 
  def __eq__(self, other):
21153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21154 
 
21155 
  def __ne__(self, other):
21156 
    return not (self == other)
21157 
 
21158 
class saveEBSSettlementSummary_result:
21159 
  """
21160 
  Attributes:
21161 
   - ex
21162 
  """
21163 
 
21164 
  thrift_spec = (
21165 
    None, # 0
21166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21167 
  )
21168 
 
21169 
  def __init__(self, ex=None,):
21170 
    self.ex = ex
21171 
 
21172 
  def read(self, iprot):
21173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21175 
      return
21176 
    iprot.readStructBegin()
21177 
    while True:
21178 
      (fname, ftype, fid) = iprot.readFieldBegin()
21179 
      if ftype == TType.STOP:
21180 
        break
21181 
      if fid == 1:
21182 
        if ftype == TType.STRUCT:
21183 
          self.ex = TransactionServiceException()
21184 
          self.ex.read(iprot)
21185 
        else:
21186 
          iprot.skip(ftype)
21187 
      else:
21188 
        iprot.skip(ftype)
21189 
      iprot.readFieldEnd()
21190 
    iprot.readStructEnd()
21191 
 
21192 
  def write(self, oprot):
21193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21195 
      return
21196 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
21197 
    if self.ex is not None:
21198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21199 
      self.ex.write(oprot)
21200 
      oprot.writeFieldEnd()
21201 
    oprot.writeFieldStop()
21202 
    oprot.writeStructEnd()
21203 
 
21204 
  def validate(self):
21205 
    return
21206 
 
21207 
 
21208 
  def __repr__(self):
21209 
    L = ['%s=%r' % (key, value)
21210 
      for key, value in self.__dict__.iteritems()]
21211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21212 
 
21213 
  def __eq__(self, other):
21214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21215 
 
21216 
  def __ne__(self, other):
21217 
    return not (self == other)
21218 
 
5386 phani.kuma 21219 
class getSettlementForPrepaid_args:
4600 varun.gupt 21220 
  """
21221 
  Attributes:
5189 varun.gupt 21222 
   - referenceId
21223 
   - isRefund
4600 varun.gupt 21224 
  """
21225 
 
21226 
  thrift_spec = (
21227 
    None, # 0
5189 varun.gupt 21228 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 21229 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 21230 
  )
21231 
 
5386 phani.kuma 21232 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 21233 
    self.referenceId = referenceId
21234 
    self.isRefund = isRefund
4600 varun.gupt 21235 
 
21236 
  def read(self, iprot):
21237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21239 
      return
21240 
    iprot.readStructBegin()
21241 
    while True:
21242 
      (fname, ftype, fid) = iprot.readFieldBegin()
21243 
      if ftype == TType.STOP:
21244 
        break
21245 
      if fid == 1:
21246 
        if ftype == TType.I64:
5189 varun.gupt 21247 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21248 
        else:
21249 
          iprot.skip(ftype)
5189 varun.gupt 21250 
      elif fid == 2:
21251 
        if ftype == TType.BOOL:
21252 
          self.isRefund = iprot.readBool();
21253 
        else:
21254 
          iprot.skip(ftype)
4600 varun.gupt 21255 
      else:
21256 
        iprot.skip(ftype)
21257 
      iprot.readFieldEnd()
21258 
    iprot.readStructEnd()
21259 
 
21260 
  def write(self, oprot):
21261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21263 
      return
5386 phani.kuma 21264 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 21265 
    if self.referenceId is not None:
21266 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
21267 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21268 
      oprot.writeFieldEnd()
5386 phani.kuma 21269 
    if self.isRefund is not None:
21270 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
21271 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 21272 
      oprot.writeFieldEnd()
5386 phani.kuma 21273 
    oprot.writeFieldStop()
21274 
    oprot.writeStructEnd()
21275 
 
21276 
  def validate(self):
21277 
    return
21278 
 
21279 
 
21280 
  def __repr__(self):
21281 
    L = ['%s=%r' % (key, value)
21282 
      for key, value in self.__dict__.iteritems()]
21283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21284 
 
21285 
  def __eq__(self, other):
21286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21287 
 
21288 
  def __ne__(self, other):
21289 
    return not (self == other)
21290 
 
21291 
class getSettlementForPrepaid_result:
21292 
  """
21293 
  Attributes:
21294 
   - success
21295 
   - ex
21296 
  """
21297 
 
21298 
  thrift_spec = (
21299 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21301 
  )
21302 
 
21303 
  def __init__(self, success=None, ex=None,):
21304 
    self.success = success
21305 
    self.ex = ex
21306 
 
21307 
  def read(self, iprot):
21308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21310 
      return
21311 
    iprot.readStructBegin()
21312 
    while True:
21313 
      (fname, ftype, fid) = iprot.readFieldBegin()
21314 
      if ftype == TType.STOP:
21315 
        break
21316 
      if fid == 0:
21317 
        if ftype == TType.STRUCT:
21318 
          self.success = PaymentSettlement()
21319 
          self.success.read(iprot)
21320 
        else:
21321 
          iprot.skip(ftype)
21322 
      elif fid == 1:
21323 
        if ftype == TType.STRUCT:
21324 
          self.ex = TransactionServiceException()
21325 
          self.ex.read(iprot)
21326 
        else:
21327 
          iprot.skip(ftype)
21328 
      else:
21329 
        iprot.skip(ftype)
21330 
      iprot.readFieldEnd()
21331 
    iprot.readStructEnd()
21332 
 
21333 
  def write(self, oprot):
21334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21336 
      return
21337 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21338 
    if self.success is not None:
21339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21340 
      self.success.write(oprot)
21341 
      oprot.writeFieldEnd()
21342 
    if self.ex is not None:
21343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21344 
      self.ex.write(oprot)
21345 
      oprot.writeFieldEnd()
21346 
    oprot.writeFieldStop()
21347 
    oprot.writeStructEnd()
21348 
 
21349 
  def validate(self):
21350 
    return
21351 
 
21352 
 
21353 
  def __repr__(self):
21354 
    L = ['%s=%r' % (key, value)
21355 
      for key, value in self.__dict__.iteritems()]
21356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21357 
 
21358 
  def __eq__(self, other):
21359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21360 
 
21361 
  def __ne__(self, other):
21362 
    return not (self == other)
21363 
 
21364 
class getSettlementForCod_args:
21365 
  """
21366 
  Attributes:
21367 
   - orderId
21368 
   - isRefund
21369 
  """
21370 
 
21371 
  thrift_spec = (
21372 
    None, # 0
21373 
    (1, TType.I64, 'orderId', None, None, ), # 1
21374 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21375 
  )
21376 
 
21377 
  def __init__(self, orderId=None, isRefund=None,):
21378 
    self.orderId = orderId
21379 
    self.isRefund = isRefund
21380 
 
21381 
  def read(self, iprot):
21382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21384 
      return
21385 
    iprot.readStructBegin()
21386 
    while True:
21387 
      (fname, ftype, fid) = iprot.readFieldBegin()
21388 
      if ftype == TType.STOP:
21389 
        break
21390 
      if fid == 1:
21391 
        if ftype == TType.I64:
21392 
          self.orderId = iprot.readI64();
21393 
        else:
21394 
          iprot.skip(ftype)
21395 
      elif fid == 2:
21396 
        if ftype == TType.BOOL:
21397 
          self.isRefund = iprot.readBool();
21398 
        else:
21399 
          iprot.skip(ftype)
21400 
      else:
21401 
        iprot.skip(ftype)
21402 
      iprot.readFieldEnd()
21403 
    iprot.readStructEnd()
21404 
 
21405 
  def write(self, oprot):
21406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21408 
      return
21409 
    oprot.writeStructBegin('getSettlementForCod_args')
21410 
    if self.orderId is not None:
21411 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21412 
      oprot.writeI64(self.orderId)
21413 
      oprot.writeFieldEnd()
5189 varun.gupt 21414 
    if self.isRefund is not None:
5386 phani.kuma 21415 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21416 
      oprot.writeBool(self.isRefund)
21417 
      oprot.writeFieldEnd()
4600 varun.gupt 21418 
    oprot.writeFieldStop()
21419 
    oprot.writeStructEnd()
21420 
 
21421 
  def validate(self):
21422 
    return
21423 
 
21424 
 
21425 
  def __repr__(self):
21426 
    L = ['%s=%r' % (key, value)
21427 
      for key, value in self.__dict__.iteritems()]
21428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21429 
 
21430 
  def __eq__(self, other):
21431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21432 
 
21433 
  def __ne__(self, other):
21434 
    return not (self == other)
21435 
 
5386 phani.kuma 21436 
class getSettlementForCod_result:
4600 varun.gupt 21437 
  """
21438 
  Attributes:
21439 
   - success
21440 
   - ex
21441 
  """
21442 
 
21443 
  thrift_spec = (
21444 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21446 
  )
21447 
 
21448 
  def __init__(self, success=None, ex=None,):
21449 
    self.success = success
21450 
    self.ex = ex
21451 
 
21452 
  def read(self, iprot):
21453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21455 
      return
21456 
    iprot.readStructBegin()
21457 
    while True:
21458 
      (fname, ftype, fid) = iprot.readFieldBegin()
21459 
      if ftype == TType.STOP:
21460 
        break
21461 
      if fid == 0:
21462 
        if ftype == TType.STRUCT:
21463 
          self.success = PaymentSettlement()
21464 
          self.success.read(iprot)
21465 
        else:
21466 
          iprot.skip(ftype)
21467 
      elif fid == 1:
21468 
        if ftype == TType.STRUCT:
21469 
          self.ex = TransactionServiceException()
21470 
          self.ex.read(iprot)
21471 
        else:
21472 
          iprot.skip(ftype)
21473 
      else:
21474 
        iprot.skip(ftype)
21475 
      iprot.readFieldEnd()
21476 
    iprot.readStructEnd()
21477 
 
21478 
  def write(self, oprot):
21479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21481 
      return
5386 phani.kuma 21482 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21483 
    if self.success is not None:
21484 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21485 
      self.success.write(oprot)
21486 
      oprot.writeFieldEnd()
21487 
    if self.ex is not None:
21488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21489 
      self.ex.write(oprot)
21490 
      oprot.writeFieldEnd()
21491 
    oprot.writeFieldStop()
21492 
    oprot.writeStructEnd()
21493 
 
21494 
  def validate(self):
21495 
    return
21496 
 
21497 
 
21498 
  def __repr__(self):
21499 
    L = ['%s=%r' % (key, value)
21500 
      for key, value in self.__dict__.iteritems()]
21501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21502 
 
21503 
  def __eq__(self, other):
21504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21505 
 
21506 
  def __ne__(self, other):
21507 
    return not (self == other)
21508 
 
21509 
class getEBSSettlementSummaries_args:
21510 
 
21511 
  thrift_spec = (
21512 
  )
21513 
 
21514 
  def read(self, iprot):
21515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21517 
      return
21518 
    iprot.readStructBegin()
21519 
    while True:
21520 
      (fname, ftype, fid) = iprot.readFieldBegin()
21521 
      if ftype == TType.STOP:
21522 
        break
21523 
      else:
21524 
        iprot.skip(ftype)
21525 
      iprot.readFieldEnd()
21526 
    iprot.readStructEnd()
21527 
 
21528 
  def write(self, oprot):
21529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21531 
      return
21532 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
21533 
    oprot.writeFieldStop()
21534 
    oprot.writeStructEnd()
21535 
 
21536 
  def validate(self):
21537 
    return
21538 
 
21539 
 
21540 
  def __repr__(self):
21541 
    L = ['%s=%r' % (key, value)
21542 
      for key, value in self.__dict__.iteritems()]
21543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21544 
 
21545 
  def __eq__(self, other):
21546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21547 
 
21548 
  def __ne__(self, other):
21549 
    return not (self == other)
21550 
 
21551 
class getEBSSettlementSummaries_result:
21552 
  """
21553 
  Attributes:
21554 
   - success
21555 
   - ex
21556 
  """
21557 
 
21558 
  thrift_spec = (
21559 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
21560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21561 
  )
21562 
 
21563 
  def __init__(self, success=None, ex=None,):
21564 
    self.success = success
21565 
    self.ex = ex
21566 
 
21567 
  def read(self, iprot):
21568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21570 
      return
21571 
    iprot.readStructBegin()
21572 
    while True:
21573 
      (fname, ftype, fid) = iprot.readFieldBegin()
21574 
      if ftype == TType.STOP:
21575 
        break
21576 
      if fid == 0:
21577 
        if ftype == TType.MAP:
21578 
          self.success = {}
5481 phani.kuma 21579 
          (_ktype498, _vtype499, _size497 ) = iprot.readMapBegin()
21580 
          for _i501 in xrange(_size497):
21581 
            _key502 = iprot.readI64();
21582 
            _val503 = iprot.readString();
21583 
            self.success[_key502] = _val503
4600 varun.gupt 21584 
          iprot.readMapEnd()
21585 
        else:
21586 
          iprot.skip(ftype)
21587 
      elif fid == 1:
21588 
        if ftype == TType.STRUCT:
21589 
          self.ex = TransactionServiceException()
21590 
          self.ex.read(iprot)
21591 
        else:
21592 
          iprot.skip(ftype)
21593 
      else:
21594 
        iprot.skip(ftype)
21595 
      iprot.readFieldEnd()
21596 
    iprot.readStructEnd()
21597 
 
21598 
  def write(self, oprot):
21599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21601 
      return
21602 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
21603 
    if self.success is not None:
21604 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21605 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5481 phani.kuma 21606 
      for kiter504,viter505 in self.success.items():
21607 
        oprot.writeI64(kiter504)
21608 
        oprot.writeString(viter505)
4600 varun.gupt 21609 
      oprot.writeMapEnd()
21610 
      oprot.writeFieldEnd()
21611 
    if self.ex is not None:
21612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21613 
      self.ex.write(oprot)
21614 
      oprot.writeFieldEnd()
21615 
    oprot.writeFieldStop()
21616 
    oprot.writeStructEnd()
21617 
 
21618 
  def validate(self):
21619 
    return
21620 
 
21621 
 
21622 
  def __repr__(self):
21623 
    L = ['%s=%r' % (key, value)
21624 
      for key, value in self.__dict__.iteritems()]
21625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21626 
 
21627 
  def __eq__(self, other):
21628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21629 
 
21630 
  def __ne__(self, other):
21631 
    return not (self == other)
21632 
 
21633 
class markEBSSettlementUploaded_args:
21634 
  """
21635 
  Attributes:
21636 
   - settlementId
21637 
  """
21638 
 
21639 
  thrift_spec = (
21640 
    None, # 0
21641 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21642 
  )
21643 
 
21644 
  def __init__(self, settlementId=None,):
21645 
    self.settlementId = settlementId
21646 
 
21647 
  def read(self, iprot):
21648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21650 
      return
21651 
    iprot.readStructBegin()
21652 
    while True:
21653 
      (fname, ftype, fid) = iprot.readFieldBegin()
21654 
      if ftype == TType.STOP:
21655 
        break
21656 
      if fid == 1:
21657 
        if ftype == TType.I64:
21658 
          self.settlementId = iprot.readI64();
21659 
        else:
21660 
          iprot.skip(ftype)
21661 
      else:
21662 
        iprot.skip(ftype)
21663 
      iprot.readFieldEnd()
21664 
    iprot.readStructEnd()
21665 
 
21666 
  def write(self, oprot):
21667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21669 
      return
21670 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
21671 
    if self.settlementId is not None:
21672 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21673 
      oprot.writeI64(self.settlementId)
21674 
      oprot.writeFieldEnd()
21675 
    oprot.writeFieldStop()
21676 
    oprot.writeStructEnd()
21677 
 
21678 
  def validate(self):
21679 
    return
21680 
 
21681 
 
21682 
  def __repr__(self):
21683 
    L = ['%s=%r' % (key, value)
21684 
      for key, value in self.__dict__.iteritems()]
21685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21686 
 
21687 
  def __eq__(self, other):
21688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21689 
 
21690 
  def __ne__(self, other):
21691 
    return not (self == other)
21692 
 
21693 
class markEBSSettlementUploaded_result:
21694 
  """
21695 
  Attributes:
21696 
   - ex
21697 
  """
21698 
 
21699 
  thrift_spec = (
21700 
    None, # 0
21701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21702 
  )
21703 
 
21704 
  def __init__(self, ex=None,):
21705 
    self.ex = ex
21706 
 
21707 
  def read(self, iprot):
21708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21710 
      return
21711 
    iprot.readStructBegin()
21712 
    while True:
21713 
      (fname, ftype, fid) = iprot.readFieldBegin()
21714 
      if ftype == TType.STOP:
21715 
        break
21716 
      if fid == 1:
21717 
        if ftype == TType.STRUCT:
21718 
          self.ex = TransactionServiceException()
21719 
          self.ex.read(iprot)
21720 
        else:
21721 
          iprot.skip(ftype)
21722 
      else:
21723 
        iprot.skip(ftype)
21724 
      iprot.readFieldEnd()
21725 
    iprot.readStructEnd()
21726 
 
21727 
  def write(self, oprot):
21728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21730 
      return
21731 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21732 
    if self.ex is not None:
21733 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21734 
      self.ex.write(oprot)
21735 
      oprot.writeFieldEnd()
21736 
    oprot.writeFieldStop()
21737 
    oprot.writeStructEnd()
21738 
 
21739 
  def validate(self):
21740 
    return
21741 
 
21742 
 
21743 
  def __repr__(self):
21744 
    L = ['%s=%r' % (key, value)
21745 
      for key, value in self.__dict__.iteritems()]
21746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21747 
 
21748 
  def __eq__(self, other):
21749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21750 
 
21751 
  def __ne__(self, other):
21752 
    return not (self == other)
21753 
 
21754 
class getEBSSettlementDate_args:
21755 
  """
21756 
  Attributes:
21757 
   - settlementId
21758 
  """
21759 
 
21760 
  thrift_spec = (
21761 
    None, # 0
21762 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21763 
  )
21764 
 
21765 
  def __init__(self, settlementId=None,):
21766 
    self.settlementId = settlementId
21767 
 
21768 
  def read(self, iprot):
21769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21771 
      return
21772 
    iprot.readStructBegin()
21773 
    while True:
21774 
      (fname, ftype, fid) = iprot.readFieldBegin()
21775 
      if ftype == TType.STOP:
21776 
        break
21777 
      if fid == 1:
21778 
        if ftype == TType.I64:
21779 
          self.settlementId = iprot.readI64();
21780 
        else:
21781 
          iprot.skip(ftype)
21782 
      else:
21783 
        iprot.skip(ftype)
21784 
      iprot.readFieldEnd()
21785 
    iprot.readStructEnd()
21786 
 
21787 
  def write(self, oprot):
21788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21790 
      return
21791 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21792 
    if self.settlementId is not None:
21793 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21794 
      oprot.writeI64(self.settlementId)
21795 
      oprot.writeFieldEnd()
21796 
    oprot.writeFieldStop()
21797 
    oprot.writeStructEnd()
21798 
 
21799 
  def validate(self):
21800 
    return
21801 
 
21802 
 
21803 
  def __repr__(self):
21804 
    L = ['%s=%r' % (key, value)
21805 
      for key, value in self.__dict__.iteritems()]
21806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21807 
 
21808 
  def __eq__(self, other):
21809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21810 
 
21811 
  def __ne__(self, other):
21812 
    return not (self == other)
21813 
 
21814 
class getEBSSettlementDate_result:
21815 
  """
21816 
  Attributes:
21817 
   - success
21818 
   - ex
21819 
  """
21820 
 
21821 
  thrift_spec = (
21822 
    (0, TType.I64, 'success', None, None, ), # 0
21823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21824 
  )
21825 
 
21826 
  def __init__(self, success=None, ex=None,):
21827 
    self.success = success
21828 
    self.ex = ex
21829 
 
21830 
  def read(self, iprot):
21831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21833 
      return
21834 
    iprot.readStructBegin()
21835 
    while True:
21836 
      (fname, ftype, fid) = iprot.readFieldBegin()
21837 
      if ftype == TType.STOP:
21838 
        break
21839 
      if fid == 0:
21840 
        if ftype == TType.I64:
21841 
          self.success = iprot.readI64();
21842 
        else:
21843 
          iprot.skip(ftype)
21844 
      elif fid == 1:
21845 
        if ftype == TType.STRUCT:
21846 
          self.ex = TransactionServiceException()
21847 
          self.ex.read(iprot)
21848 
        else:
21849 
          iprot.skip(ftype)
21850 
      else:
21851 
        iprot.skip(ftype)
21852 
      iprot.readFieldEnd()
21853 
    iprot.readStructEnd()
21854 
 
21855 
  def write(self, oprot):
21856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21858 
      return
21859 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21860 
    if self.success is not None:
21861 
      oprot.writeFieldBegin('success', TType.I64, 0)
21862 
      oprot.writeI64(self.success)
21863 
      oprot.writeFieldEnd()
21864 
    if self.ex is not None:
21865 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21866 
      self.ex.write(oprot)
21867 
      oprot.writeFieldEnd()
21868 
    oprot.writeFieldStop()
21869 
    oprot.writeStructEnd()
21870 
 
21871 
  def validate(self):
21872 
    return
21873 
 
21874 
 
21875 
  def __repr__(self):
21876 
    L = ['%s=%r' % (key, value)
21877 
      for key, value in self.__dict__.iteritems()]
21878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21879 
 
21880 
  def __eq__(self, other):
21881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21882 
 
21883 
  def __ne__(self, other):
21884 
    return not (self == other)
4715 varun.gupt 21885 
 
21886 
class getSettlementsByDate_args:
21887 
  """
21888 
  Attributes:
21889 
   - settlementDateFrom
21890 
   - settlementDateTo
21891 
   - isRefund
21892 
  """
21893 
 
21894 
  thrift_spec = (
21895 
    None, # 0
21896 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21897 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21898 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21899 
  )
21900 
 
21901 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21902 
    self.settlementDateFrom = settlementDateFrom
21903 
    self.settlementDateTo = settlementDateTo
21904 
    self.isRefund = isRefund
21905 
 
21906 
  def read(self, iprot):
21907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21909 
      return
21910 
    iprot.readStructBegin()
21911 
    while True:
21912 
      (fname, ftype, fid) = iprot.readFieldBegin()
21913 
      if ftype == TType.STOP:
21914 
        break
21915 
      if fid == 1:
21916 
        if ftype == TType.I64:
21917 
          self.settlementDateFrom = iprot.readI64();
21918 
        else:
21919 
          iprot.skip(ftype)
21920 
      elif fid == 2:
21921 
        if ftype == TType.I64:
21922 
          self.settlementDateTo = iprot.readI64();
21923 
        else:
21924 
          iprot.skip(ftype)
21925 
      elif fid == 3:
21926 
        if ftype == TType.BOOL:
21927 
          self.isRefund = iprot.readBool();
21928 
        else:
21929 
          iprot.skip(ftype)
21930 
      else:
21931 
        iprot.skip(ftype)
21932 
      iprot.readFieldEnd()
21933 
    iprot.readStructEnd()
21934 
 
21935 
  def write(self, oprot):
21936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21938 
      return
21939 
    oprot.writeStructBegin('getSettlementsByDate_args')
21940 
    if self.settlementDateFrom is not None:
21941 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21942 
      oprot.writeI64(self.settlementDateFrom)
21943 
      oprot.writeFieldEnd()
21944 
    if self.settlementDateTo is not None:
21945 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21946 
      oprot.writeI64(self.settlementDateTo)
21947 
      oprot.writeFieldEnd()
21948 
    if self.isRefund is not None:
21949 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21950 
      oprot.writeBool(self.isRefund)
21951 
      oprot.writeFieldEnd()
21952 
    oprot.writeFieldStop()
21953 
    oprot.writeStructEnd()
21954 
 
21955 
  def validate(self):
21956 
    return
21957 
 
21958 
 
21959 
  def __repr__(self):
21960 
    L = ['%s=%r' % (key, value)
21961 
      for key, value in self.__dict__.iteritems()]
21962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21963 
 
21964 
  def __eq__(self, other):
21965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21966 
 
21967 
  def __ne__(self, other):
21968 
    return not (self == other)
21969 
 
21970 
class getSettlementsByDate_result:
21971 
  """
21972 
  Attributes:
21973 
   - success
21974 
   - ex
21975 
  """
21976 
 
21977 
  thrift_spec = (
21978 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21980 
  )
21981 
 
21982 
  def __init__(self, success=None, ex=None,):
21983 
    self.success = success
21984 
    self.ex = ex
21985 
 
21986 
  def read(self, iprot):
21987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21989 
      return
21990 
    iprot.readStructBegin()
21991 
    while True:
21992 
      (fname, ftype, fid) = iprot.readFieldBegin()
21993 
      if ftype == TType.STOP:
21994 
        break
21995 
      if fid == 0:
21996 
        if ftype == TType.LIST:
21997 
          self.success = []
5481 phani.kuma 21998 
          (_etype509, _size506) = iprot.readListBegin()
21999 
          for _i510 in xrange(_size506):
22000 
            _elem511 = PaymentSettlement()
22001 
            _elem511.read(iprot)
22002 
            self.success.append(_elem511)
4715 varun.gupt 22003 
          iprot.readListEnd()
22004 
        else:
22005 
          iprot.skip(ftype)
22006 
      elif fid == 1:
22007 
        if ftype == TType.STRUCT:
22008 
          self.ex = TransactionServiceException()
22009 
          self.ex.read(iprot)
22010 
        else:
22011 
          iprot.skip(ftype)
22012 
      else:
22013 
        iprot.skip(ftype)
22014 
      iprot.readFieldEnd()
22015 
    iprot.readStructEnd()
22016 
 
22017 
  def write(self, oprot):
22018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22020 
      return
22021 
    oprot.writeStructBegin('getSettlementsByDate_result')
22022 
    if self.success is not None:
22023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22025 
      for iter512 in self.success:
22026 
        iter512.write(oprot)
4715 varun.gupt 22027 
      oprot.writeListEnd()
22028 
      oprot.writeFieldEnd()
22029 
    if self.ex is not None:
22030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22031 
      self.ex.write(oprot)
22032 
      oprot.writeFieldEnd()
22033 
    oprot.writeFieldStop()
22034 
    oprot.writeStructEnd()
22035 
 
22036 
  def validate(self):
22037 
    return
22038 
 
22039 
 
22040 
  def __repr__(self):
22041 
    L = ['%s=%r' % (key, value)
22042 
      for key, value in self.__dict__.iteritems()]
22043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22044 
 
22045 
  def __eq__(self, other):
22046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22047 
 
22048 
  def __ne__(self, other):
22049 
    return not (self == other)
22050 
 
22051 
class getReshippedOrderIds_args:
22052 
  """
22053 
  Attributes:
22054 
   - orderIds
22055 
  """
22056 
 
22057 
  thrift_spec = (
22058 
    None, # 0
22059 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22060 
  )
22061 
 
22062 
  def __init__(self, orderIds=None,):
22063 
    self.orderIds = orderIds
22064 
 
22065 
  def read(self, iprot):
22066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22068 
      return
22069 
    iprot.readStructBegin()
22070 
    while True:
22071 
      (fname, ftype, fid) = iprot.readFieldBegin()
22072 
      if ftype == TType.STOP:
22073 
        break
22074 
      if fid == 1:
22075 
        if ftype == TType.LIST:
22076 
          self.orderIds = []
5481 phani.kuma 22077 
          (_etype516, _size513) = iprot.readListBegin()
22078 
          for _i517 in xrange(_size513):
22079 
            _elem518 = iprot.readI64();
22080 
            self.orderIds.append(_elem518)
4715 varun.gupt 22081 
          iprot.readListEnd()
22082 
        else:
22083 
          iprot.skip(ftype)
22084 
      else:
22085 
        iprot.skip(ftype)
22086 
      iprot.readFieldEnd()
22087 
    iprot.readStructEnd()
22088 
 
22089 
  def write(self, oprot):
22090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22092 
      return
22093 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22094 
    if self.orderIds is not None:
22095 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22096 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5481 phani.kuma 22097 
      for iter519 in self.orderIds:
22098 
        oprot.writeI64(iter519)
4715 varun.gupt 22099 
      oprot.writeListEnd()
22100 
      oprot.writeFieldEnd()
22101 
    oprot.writeFieldStop()
22102 
    oprot.writeStructEnd()
22103 
 
22104 
  def validate(self):
22105 
    return
22106 
 
22107 
 
22108 
  def __repr__(self):
22109 
    L = ['%s=%r' % (key, value)
22110 
      for key, value in self.__dict__.iteritems()]
22111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22112 
 
22113 
  def __eq__(self, other):
22114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22115 
 
22116 
  def __ne__(self, other):
22117 
    return not (self == other)
22118 
 
22119 
class getReshippedOrderIds_result:
22120 
  """
22121 
  Attributes:
22122 
   - success
22123 
   - ex
22124 
  """
22125 
 
22126 
  thrift_spec = (
22127 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22129 
  )
22130 
 
22131 
  def __init__(self, success=None, ex=None,):
22132 
    self.success = success
22133 
    self.ex = ex
22134 
 
22135 
  def read(self, iprot):
22136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22138 
      return
22139 
    iprot.readStructBegin()
22140 
    while True:
22141 
      (fname, ftype, fid) = iprot.readFieldBegin()
22142 
      if ftype == TType.STOP:
22143 
        break
22144 
      if fid == 0:
22145 
        if ftype == TType.LIST:
22146 
          self.success = []
5481 phani.kuma 22147 
          (_etype523, _size520) = iprot.readListBegin()
22148 
          for _i524 in xrange(_size520):
22149 
            _elem525 = iprot.readI64();
22150 
            self.success.append(_elem525)
4715 varun.gupt 22151 
          iprot.readListEnd()
22152 
        else:
22153 
          iprot.skip(ftype)
22154 
      elif fid == 1:
22155 
        if ftype == TType.STRUCT:
22156 
          self.ex = TransactionServiceException()
22157 
          self.ex.read(iprot)
22158 
        else:
22159 
          iprot.skip(ftype)
22160 
      else:
22161 
        iprot.skip(ftype)
22162 
      iprot.readFieldEnd()
22163 
    iprot.readStructEnd()
22164 
 
22165 
  def write(self, oprot):
22166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22168 
      return
22169 
    oprot.writeStructBegin('getReshippedOrderIds_result')
22170 
    if self.success is not None:
22171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22172 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 22173 
      for iter526 in self.success:
22174 
        oprot.writeI64(iter526)
4715 varun.gupt 22175 
      oprot.writeListEnd()
22176 
      oprot.writeFieldEnd()
22177 
    if self.ex is not None:
22178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22179 
      self.ex.write(oprot)
22180 
      oprot.writeFieldEnd()
22181 
    oprot.writeFieldStop()
22182 
    oprot.writeStructEnd()
22183 
 
22184 
  def validate(self):
22185 
    return
22186 
 
22187 
 
22188 
  def __repr__(self):
22189 
    L = ['%s=%r' % (key, value)
22190 
      for key, value in self.__dict__.iteritems()]
22191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22192 
 
22193 
  def __eq__(self, other):
22194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22195 
 
22196 
  def __ne__(self, other):
22197 
    return not (self == other)
4757 mandeep.dh 22198 
 
5481 phani.kuma 22199 
class getBilledOrders_args:
4875 varun.gupt 22200 
  """
22201 
  Attributes:
22202 
   - vendorId
5481 phani.kuma 22203 
   - onlyVendorNotPaid
22204 
   - billingDateFrom
22205 
   - billingDateTo
4875 varun.gupt 22206 
  """
22207 
 
22208 
  thrift_spec = (
22209 
    None, # 0
22210 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 22211 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
22212 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
22213 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 22214 
  )
22215 
 
5481 phani.kuma 22216 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 22217 
    self.vendorId = vendorId
5481 phani.kuma 22218 
    self.onlyVendorNotPaid = onlyVendorNotPaid
22219 
    self.billingDateFrom = billingDateFrom
22220 
    self.billingDateTo = billingDateTo
4875 varun.gupt 22221 
 
22222 
  def read(self, iprot):
22223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22225 
      return
22226 
    iprot.readStructBegin()
22227 
    while True:
22228 
      (fname, ftype, fid) = iprot.readFieldBegin()
22229 
      if ftype == TType.STOP:
22230 
        break
22231 
      if fid == 1:
22232 
        if ftype == TType.I64:
22233 
          self.vendorId = iprot.readI64();
22234 
        else:
22235 
          iprot.skip(ftype)
5481 phani.kuma 22236 
      elif fid == 2:
22237 
        if ftype == TType.BOOL:
22238 
          self.onlyVendorNotPaid = iprot.readBool();
22239 
        else:
22240 
          iprot.skip(ftype)
22241 
      elif fid == 3:
22242 
        if ftype == TType.I64:
22243 
          self.billingDateFrom = iprot.readI64();
22244 
        else:
22245 
          iprot.skip(ftype)
22246 
      elif fid == 4:
22247 
        if ftype == TType.I64:
22248 
          self.billingDateTo = iprot.readI64();
22249 
        else:
22250 
          iprot.skip(ftype)
4875 varun.gupt 22251 
      else:
22252 
        iprot.skip(ftype)
22253 
      iprot.readFieldEnd()
22254 
    iprot.readStructEnd()
22255 
 
22256 
  def write(self, oprot):
22257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22259 
      return
5481 phani.kuma 22260 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 22261 
    if self.vendorId is not None:
22262 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22263 
      oprot.writeI64(self.vendorId)
22264 
      oprot.writeFieldEnd()
5481 phani.kuma 22265 
    if self.onlyVendorNotPaid is not None:
22266 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
22267 
      oprot.writeBool(self.onlyVendorNotPaid)
22268 
      oprot.writeFieldEnd()
22269 
    if self.billingDateFrom is not None:
22270 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
22271 
      oprot.writeI64(self.billingDateFrom)
22272 
      oprot.writeFieldEnd()
22273 
    if self.billingDateTo is not None:
22274 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
22275 
      oprot.writeI64(self.billingDateTo)
22276 
      oprot.writeFieldEnd()
4875 varun.gupt 22277 
    oprot.writeFieldStop()
22278 
    oprot.writeStructEnd()
22279 
 
22280 
  def validate(self):
22281 
    return
22282 
 
22283 
 
22284 
  def __repr__(self):
22285 
    L = ['%s=%r' % (key, value)
22286 
      for key, value in self.__dict__.iteritems()]
22287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22288 
 
22289 
  def __eq__(self, other):
22290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22291 
 
22292 
  def __ne__(self, other):
22293 
    return not (self == other)
22294 
 
5481 phani.kuma 22295 
class getBilledOrders_result:
4875 varun.gupt 22296 
  """
22297 
  Attributes:
22298 
   - success
22299 
   - ex
22300 
  """
22301 
 
22302 
  thrift_spec = (
22303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22305 
  )
22306 
 
22307 
  def __init__(self, success=None, ex=None,):
22308 
    self.success = success
22309 
    self.ex = ex
22310 
 
22311 
  def read(self, iprot):
22312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22314 
      return
22315 
    iprot.readStructBegin()
22316 
    while True:
22317 
      (fname, ftype, fid) = iprot.readFieldBegin()
22318 
      if ftype == TType.STOP:
22319 
        break
22320 
      if fid == 0:
22321 
        if ftype == TType.LIST:
22322 
          self.success = []
5481 phani.kuma 22323 
          (_etype530, _size527) = iprot.readListBegin()
22324 
          for _i531 in xrange(_size527):
22325 
            _elem532 = Order()
22326 
            _elem532.read(iprot)
22327 
            self.success.append(_elem532)
4875 varun.gupt 22328 
          iprot.readListEnd()
22329 
        else:
22330 
          iprot.skip(ftype)
22331 
      elif fid == 1:
22332 
        if ftype == TType.STRUCT:
22333 
          self.ex = TransactionServiceException()
22334 
          self.ex.read(iprot)
22335 
        else:
22336 
          iprot.skip(ftype)
22337 
      else:
22338 
        iprot.skip(ftype)
22339 
      iprot.readFieldEnd()
22340 
    iprot.readStructEnd()
22341 
 
22342 
  def write(self, oprot):
22343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22345 
      return
5481 phani.kuma 22346 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 22347 
    if self.success is not None:
22348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 22350 
      for iter533 in self.success:
22351 
        iter533.write(oprot)
4875 varun.gupt 22352 
      oprot.writeListEnd()
22353 
      oprot.writeFieldEnd()
22354 
    if self.ex is not None:
22355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22356 
      self.ex.write(oprot)
22357 
      oprot.writeFieldEnd()
22358 
    oprot.writeFieldStop()
22359 
    oprot.writeStructEnd()
22360 
 
22361 
  def validate(self):
22362 
    return
22363 
 
22364 
 
22365 
  def __repr__(self):
22366 
    L = ['%s=%r' % (key, value)
22367 
      for key, value in self.__dict__.iteritems()]
22368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22369 
 
22370 
  def __eq__(self, other):
22371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22372 
 
22373 
  def __ne__(self, other):
22374 
    return not (self == other)
5031 varun.gupt 22375 
 
22376 
class getStatusDistributionOfOrders_args:
22377 
  """
22378 
  Attributes:
22379 
   - startDate
22380 
   - endDate
22381 
  """
22382 
 
22383 
  thrift_spec = (
22384 
    None, # 0
22385 
    (1, TType.I64, 'startDate', None, None, ), # 1
22386 
    (2, TType.I64, 'endDate', None, None, ), # 2
22387 
  )
22388 
 
22389 
  def __init__(self, startDate=None, endDate=None,):
22390 
    self.startDate = startDate
22391 
    self.endDate = endDate
22392 
 
22393 
  def read(self, iprot):
22394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22396 
      return
22397 
    iprot.readStructBegin()
22398 
    while True:
22399 
      (fname, ftype, fid) = iprot.readFieldBegin()
22400 
      if ftype == TType.STOP:
22401 
        break
22402 
      if fid == 1:
22403 
        if ftype == TType.I64:
22404 
          self.startDate = iprot.readI64();
22405 
        else:
22406 
          iprot.skip(ftype)
22407 
      elif fid == 2:
22408 
        if ftype == TType.I64:
22409 
          self.endDate = iprot.readI64();
22410 
        else:
22411 
          iprot.skip(ftype)
22412 
      else:
22413 
        iprot.skip(ftype)
22414 
      iprot.readFieldEnd()
22415 
    iprot.readStructEnd()
22416 
 
22417 
  def write(self, oprot):
22418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22420 
      return
22421 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22422 
    if self.startDate is not None:
22423 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22424 
      oprot.writeI64(self.startDate)
22425 
      oprot.writeFieldEnd()
22426 
    if self.endDate is not None:
22427 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22428 
      oprot.writeI64(self.endDate)
22429 
      oprot.writeFieldEnd()
22430 
    oprot.writeFieldStop()
22431 
    oprot.writeStructEnd()
22432 
 
22433 
  def validate(self):
22434 
    return
22435 
 
22436 
 
22437 
  def __repr__(self):
22438 
    L = ['%s=%r' % (key, value)
22439 
      for key, value in self.__dict__.iteritems()]
22440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22441 
 
22442 
  def __eq__(self, other):
22443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22444 
 
22445 
  def __ne__(self, other):
22446 
    return not (self == other)
22447 
 
22448 
class getStatusDistributionOfOrders_result:
22449 
  """
22450 
  Attributes:
22451 
   - success
22452 
   - ex
22453 
  """
22454 
 
22455 
  thrift_spec = (
22456 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22458 
  )
22459 
 
22460 
  def __init__(self, success=None, ex=None,):
22461 
    self.success = success
22462 
    self.ex = ex
22463 
 
22464 
  def read(self, iprot):
22465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22467 
      return
22468 
    iprot.readStructBegin()
22469 
    while True:
22470 
      (fname, ftype, fid) = iprot.readFieldBegin()
22471 
      if ftype == TType.STOP:
22472 
        break
22473 
      if fid == 0:
22474 
        if ftype == TType.MAP:
22475 
          self.success = {}
5481 phani.kuma 22476 
          (_ktype535, _vtype536, _size534 ) = iprot.readMapBegin()
22477 
          for _i538 in xrange(_size534):
22478 
            _key539 = iprot.readI64();
22479 
            _val540 = iprot.readI64();
22480 
            self.success[_key539] = _val540
5031 varun.gupt 22481 
          iprot.readMapEnd()
22482 
        else:
22483 
          iprot.skip(ftype)
22484 
      elif fid == 1:
22485 
        if ftype == TType.STRUCT:
22486 
          self.ex = TransactionServiceException()
22487 
          self.ex.read(iprot)
22488 
        else:
22489 
          iprot.skip(ftype)
22490 
      else:
22491 
        iprot.skip(ftype)
22492 
      iprot.readFieldEnd()
22493 
    iprot.readStructEnd()
22494 
 
22495 
  def write(self, oprot):
22496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22498 
      return
22499 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22500 
    if self.success is not None:
22501 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22502 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5481 phani.kuma 22503 
      for kiter541,viter542 in self.success.items():
22504 
        oprot.writeI64(kiter541)
22505 
        oprot.writeI64(viter542)
5031 varun.gupt 22506 
      oprot.writeMapEnd()
22507 
      oprot.writeFieldEnd()
22508 
    if self.ex is not None:
22509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22510 
      self.ex.write(oprot)
22511 
      oprot.writeFieldEnd()
22512 
    oprot.writeFieldStop()
22513 
    oprot.writeStructEnd()
22514 
 
22515 
  def validate(self):
22516 
    return
22517 
 
22518 
 
22519 
  def __repr__(self):
22520 
    L = ['%s=%r' % (key, value)
22521 
      for key, value in self.__dict__.iteritems()]
22522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22523 
 
22524 
  def __eq__(self, other):
22525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22526 
 
22527 
  def __ne__(self, other):
22528 
    return not (self == other)
5067 varun.gupt 22529 
 
22530 
class getOrderIdsForStatus_args:
22531 
  """
22532 
  Attributes:
22533 
   - status
22534 
   - startDatetime
22535 
   - endDatetime
22536 
  """
22537 
 
22538 
  thrift_spec = (
22539 
    None, # 0
22540 
    (1, TType.I64, 'status', None, None, ), # 1
22541 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
22542 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
22543 
  )
22544 
 
22545 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
22546 
    self.status = status
22547 
    self.startDatetime = startDatetime
22548 
    self.endDatetime = endDatetime
22549 
 
22550 
  def read(self, iprot):
22551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22553 
      return
22554 
    iprot.readStructBegin()
22555 
    while True:
22556 
      (fname, ftype, fid) = iprot.readFieldBegin()
22557 
      if ftype == TType.STOP:
22558 
        break
22559 
      if fid == 1:
22560 
        if ftype == TType.I64:
22561 
          self.status = iprot.readI64();
22562 
        else:
22563 
          iprot.skip(ftype)
22564 
      elif fid == 2:
22565 
        if ftype == TType.I64:
22566 
          self.startDatetime = iprot.readI64();
22567 
        else:
22568 
          iprot.skip(ftype)
22569 
      elif fid == 3:
22570 
        if ftype == TType.I64:
22571 
          self.endDatetime = iprot.readI64();
22572 
        else:
22573 
          iprot.skip(ftype)
22574 
      else:
22575 
        iprot.skip(ftype)
22576 
      iprot.readFieldEnd()
22577 
    iprot.readStructEnd()
22578 
 
22579 
  def write(self, oprot):
22580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22582 
      return
22583 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22584 
    if self.status is not None:
22585 
      oprot.writeFieldBegin('status', TType.I64, 1)
22586 
      oprot.writeI64(self.status)
22587 
      oprot.writeFieldEnd()
22588 
    if self.startDatetime is not None:
22589 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22590 
      oprot.writeI64(self.startDatetime)
22591 
      oprot.writeFieldEnd()
22592 
    if self.endDatetime is not None:
22593 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22594 
      oprot.writeI64(self.endDatetime)
22595 
      oprot.writeFieldEnd()
22596 
    oprot.writeFieldStop()
22597 
    oprot.writeStructEnd()
22598 
 
22599 
  def validate(self):
22600 
    return
22601 
 
22602 
 
22603 
  def __repr__(self):
22604 
    L = ['%s=%r' % (key, value)
22605 
      for key, value in self.__dict__.iteritems()]
22606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22607 
 
22608 
  def __eq__(self, other):
22609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22610 
 
22611 
  def __ne__(self, other):
22612 
    return not (self == other)
22613 
 
22614 
class getOrderIdsForStatus_result:
22615 
  """
22616 
  Attributes:
22617 
   - success
22618 
   - ex
22619 
  """
22620 
 
22621 
  thrift_spec = (
22622 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22624 
  )
22625 
 
22626 
  def __init__(self, success=None, ex=None,):
22627 
    self.success = success
22628 
    self.ex = ex
22629 
 
22630 
  def read(self, iprot):
22631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22633 
      return
22634 
    iprot.readStructBegin()
22635 
    while True:
22636 
      (fname, ftype, fid) = iprot.readFieldBegin()
22637 
      if ftype == TType.STOP:
22638 
        break
22639 
      if fid == 0:
22640 
        if ftype == TType.LIST:
22641 
          self.success = []
5481 phani.kuma 22642 
          (_etype546, _size543) = iprot.readListBegin()
22643 
          for _i547 in xrange(_size543):
22644 
            _elem548 = iprot.readI64();
22645 
            self.success.append(_elem548)
5067 varun.gupt 22646 
          iprot.readListEnd()
22647 
        else:
22648 
          iprot.skip(ftype)
22649 
      elif fid == 1:
22650 
        if ftype == TType.STRUCT:
22651 
          self.ex = TransactionServiceException()
22652 
          self.ex.read(iprot)
22653 
        else:
22654 
          iprot.skip(ftype)
22655 
      else:
22656 
        iprot.skip(ftype)
22657 
      iprot.readFieldEnd()
22658 
    iprot.readStructEnd()
22659 
 
22660 
  def write(self, oprot):
22661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22663 
      return
22664 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22665 
    if self.success is not None:
22666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22667 
      oprot.writeListBegin(TType.I64, len(self.success))
5481 phani.kuma 22668 
      for iter549 in self.success:
22669 
        oprot.writeI64(iter549)
5067 varun.gupt 22670 
      oprot.writeListEnd()
22671 
      oprot.writeFieldEnd()
22672 
    if self.ex is not None:
22673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22674 
      self.ex.write(oprot)
22675 
      oprot.writeFieldEnd()
22676 
    oprot.writeFieldStop()
22677 
    oprot.writeStructEnd()
22678 
 
22679 
  def validate(self):
22680 
    return
22681 
 
22682 
 
22683 
  def __repr__(self):
22684 
    L = ['%s=%r' % (key, value)
22685 
      for key, value in self.__dict__.iteritems()]
22686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22687 
 
22688 
  def __eq__(self, other):
22689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22690 
 
22691 
  def __ne__(self, other):
22692 
    return not (self == other)
5099 varun.gupt 22693 
 
5348 anupam.sin 22694 
class updateCODAgent_args:
22695 
  """
22696 
  Attributes:
22697 
   - agent
22698 
   - orderId
22699 
  """
22700 
 
22701 
  thrift_spec = (
22702 
    None, # 0
22703 
    (1, TType.STRING, 'agent', None, None, ), # 1
22704 
    (2, TType.I64, 'orderId', None, None, ), # 2
22705 
  )
22706 
 
22707 
  def __init__(self, agent=None, orderId=None,):
22708 
    self.agent = agent
22709 
    self.orderId = orderId
22710 
 
22711 
  def read(self, iprot):
22712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22714 
      return
22715 
    iprot.readStructBegin()
22716 
    while True:
22717 
      (fname, ftype, fid) = iprot.readFieldBegin()
22718 
      if ftype == TType.STOP:
22719 
        break
22720 
      if fid == 1:
22721 
        if ftype == TType.STRING:
22722 
          self.agent = iprot.readString();
22723 
        else:
22724 
          iprot.skip(ftype)
22725 
      elif fid == 2:
22726 
        if ftype == TType.I64:
22727 
          self.orderId = iprot.readI64();
22728 
        else:
22729 
          iprot.skip(ftype)
22730 
      else:
22731 
        iprot.skip(ftype)
22732 
      iprot.readFieldEnd()
22733 
    iprot.readStructEnd()
22734 
 
22735 
  def write(self, oprot):
22736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22738 
      return
22739 
    oprot.writeStructBegin('updateCODAgent_args')
22740 
    if self.agent is not None:
22741 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22742 
      oprot.writeString(self.agent)
22743 
      oprot.writeFieldEnd()
22744 
    if self.orderId is not None:
22745 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22746 
      oprot.writeI64(self.orderId)
22747 
      oprot.writeFieldEnd()
22748 
    oprot.writeFieldStop()
22749 
    oprot.writeStructEnd()
22750 
 
22751 
  def validate(self):
22752 
    return
22753 
 
22754 
 
22755 
  def __repr__(self):
22756 
    L = ['%s=%r' % (key, value)
22757 
      for key, value in self.__dict__.iteritems()]
22758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22759 
 
22760 
  def __eq__(self, other):
22761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22762 
 
22763 
  def __ne__(self, other):
22764 
    return not (self == other)
22765 
 
22766 
class updateCODAgent_result:
22767 
  """
22768 
  Attributes:
22769 
   - ex
22770 
  """
22771 
 
22772 
  thrift_spec = (
22773 
    None, # 0
22774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22775 
  )
22776 
 
22777 
  def __init__(self, ex=None,):
22778 
    self.ex = ex
22779 
 
22780 
  def read(self, iprot):
22781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22783 
      return
22784 
    iprot.readStructBegin()
22785 
    while True:
22786 
      (fname, ftype, fid) = iprot.readFieldBegin()
22787 
      if ftype == TType.STOP:
22788 
        break
22789 
      if fid == 1:
22790 
        if ftype == TType.STRUCT:
22791 
          self.ex = TransactionServiceException()
22792 
          self.ex.read(iprot)
22793 
        else:
22794 
          iprot.skip(ftype)
22795 
      else:
22796 
        iprot.skip(ftype)
22797 
      iprot.readFieldEnd()
22798 
    iprot.readStructEnd()
22799 
 
22800 
  def write(self, oprot):
22801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22803 
      return
22804 
    oprot.writeStructBegin('updateCODAgent_result')
22805 
    if self.ex is not None:
22806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22807 
      self.ex.write(oprot)
22808 
      oprot.writeFieldEnd()
22809 
    oprot.writeFieldStop()
22810 
    oprot.writeStructEnd()
22811 
 
22812 
  def validate(self):
22813 
    return
22814 
 
22815 
 
22816 
  def __repr__(self):
22817 
    L = ['%s=%r' % (key, value)
22818 
      for key, value in self.__dict__.iteritems()]
22819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22820 
 
22821 
  def __eq__(self, other):
22822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22823 
 
22824 
  def __ne__(self, other):
22825 
    return not (self == other)
22826 
 
5099 varun.gupt 22827 
class updateOrderAsPaidToVendor_args:
22828 
  """
22829 
  Attributes:
22830 
   - orderId
22831 
  """
22832 
 
22833 
  thrift_spec = (
22834 
    None, # 0
22835 
    (1, TType.I64, 'orderId', None, None, ), # 1
22836 
  )
22837 
 
22838 
  def __init__(self, orderId=None,):
22839 
    self.orderId = orderId
22840 
 
22841 
  def read(self, iprot):
22842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22844 
      return
22845 
    iprot.readStructBegin()
22846 
    while True:
22847 
      (fname, ftype, fid) = iprot.readFieldBegin()
22848 
      if ftype == TType.STOP:
22849 
        break
22850 
      if fid == 1:
22851 
        if ftype == TType.I64:
22852 
          self.orderId = iprot.readI64();
22853 
        else:
22854 
          iprot.skip(ftype)
22855 
      else:
22856 
        iprot.skip(ftype)
22857 
      iprot.readFieldEnd()
22858 
    iprot.readStructEnd()
22859 
 
22860 
  def write(self, oprot):
22861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22863 
      return
22864 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22865 
    if self.orderId is not None:
22866 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22867 
      oprot.writeI64(self.orderId)
22868 
      oprot.writeFieldEnd()
22869 
    oprot.writeFieldStop()
22870 
    oprot.writeStructEnd()
22871 
 
22872 
  def validate(self):
22873 
    return
22874 
 
22875 
 
22876 
  def __repr__(self):
22877 
    L = ['%s=%r' % (key, value)
22878 
      for key, value in self.__dict__.iteritems()]
22879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22880 
 
22881 
  def __eq__(self, other):
22882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22883 
 
22884 
  def __ne__(self, other):
22885 
    return not (self == other)
22886 
 
22887 
class updateOrderAsPaidToVendor_result:
22888 
  """
22889 
  Attributes:
22890 
   - ex
22891 
  """
22892 
 
22893 
  thrift_spec = (
22894 
    None, # 0
22895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22896 
  )
22897 
 
22898 
  def __init__(self, ex=None,):
22899 
    self.ex = ex
22900 
 
22901 
  def read(self, iprot):
22902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22904 
      return
22905 
    iprot.readStructBegin()
22906 
    while True:
22907 
      (fname, ftype, fid) = iprot.readFieldBegin()
22908 
      if ftype == TType.STOP:
22909 
        break
22910 
      if fid == 1:
22911 
        if ftype == TType.STRUCT:
22912 
          self.ex = TransactionServiceException()
22913 
          self.ex.read(iprot)
22914 
        else:
22915 
          iprot.skip(ftype)
22916 
      else:
22917 
        iprot.skip(ftype)
22918 
      iprot.readFieldEnd()
22919 
    iprot.readStructEnd()
22920 
 
22921 
  def write(self, oprot):
22922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22924 
      return
22925 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22926 
    if self.ex is not None:
22927 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22928 
      self.ex.write(oprot)
22929 
      oprot.writeFieldEnd()
22930 
    oprot.writeFieldStop()
22931 
    oprot.writeStructEnd()
22932 
 
22933 
  def validate(self):
22934 
    return
22935 
 
22936 
 
22937 
  def __repr__(self):
22938 
    L = ['%s=%r' % (key, value)
22939 
      for key, value in self.__dict__.iteritems()]
22940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22941 
 
22942 
  def __eq__(self, other):
22943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22944 
 
22945 
  def __ne__(self, other):
22946 
    return not (self == other)
5208 varun.gupt 22947 
 
5386 phani.kuma 22948 
class updateOrderOnlyAsPaidToVendor_args:
22949 
  """
22950 
  Attributes:
22951 
   - orderId
22952 
  """
22953 
 
22954 
  thrift_spec = (
22955 
    None, # 0
22956 
    (1, TType.I64, 'orderId', None, None, ), # 1
22957 
  )
22958 
 
22959 
  def __init__(self, orderId=None,):
22960 
    self.orderId = orderId
22961 
 
22962 
  def read(self, iprot):
22963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22965 
      return
22966 
    iprot.readStructBegin()
22967 
    while True:
22968 
      (fname, ftype, fid) = iprot.readFieldBegin()
22969 
      if ftype == TType.STOP:
22970 
        break
22971 
      if fid == 1:
22972 
        if ftype == TType.I64:
22973 
          self.orderId = iprot.readI64();
22974 
        else:
22975 
          iprot.skip(ftype)
22976 
      else:
22977 
        iprot.skip(ftype)
22978 
      iprot.readFieldEnd()
22979 
    iprot.readStructEnd()
22980 
 
22981 
  def write(self, oprot):
22982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22984 
      return
22985 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
22986 
    if self.orderId is not None:
22987 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22988 
      oprot.writeI64(self.orderId)
22989 
      oprot.writeFieldEnd()
22990 
    oprot.writeFieldStop()
22991 
    oprot.writeStructEnd()
22992 
 
22993 
  def validate(self):
22994 
    return
22995 
 
22996 
 
22997 
  def __repr__(self):
22998 
    L = ['%s=%r' % (key, value)
22999 
      for key, value in self.__dict__.iteritems()]
23000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23001 
 
23002 
  def __eq__(self, other):
23003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23004 
 
23005 
  def __ne__(self, other):
23006 
    return not (self == other)
23007 
 
23008 
class updateOrderOnlyAsPaidToVendor_result:
23009 
  """
23010 
  Attributes:
23011 
   - ex
23012 
  """
23013 
 
23014 
  thrift_spec = (
23015 
    None, # 0
23016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23017 
  )
23018 
 
23019 
  def __init__(self, ex=None,):
23020 
    self.ex = ex
23021 
 
23022 
  def read(self, iprot):
23023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23025 
      return
23026 
    iprot.readStructBegin()
23027 
    while True:
23028 
      (fname, ftype, fid) = iprot.readFieldBegin()
23029 
      if ftype == TType.STOP:
23030 
        break
23031 
      if fid == 1:
23032 
        if ftype == TType.STRUCT:
23033 
          self.ex = TransactionServiceException()
23034 
          self.ex.read(iprot)
23035 
        else:
23036 
          iprot.skip(ftype)
23037 
      else:
23038 
        iprot.skip(ftype)
23039 
      iprot.readFieldEnd()
23040 
    iprot.readStructEnd()
23041 
 
23042 
  def write(self, oprot):
23043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23045 
      return
23046 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23047 
    if self.ex is not None:
23048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23049 
      self.ex.write(oprot)
23050 
      oprot.writeFieldEnd()
23051 
    oprot.writeFieldStop()
23052 
    oprot.writeStructEnd()
23053 
 
23054 
  def validate(self):
23055 
    return
23056 
 
23057 
 
23058 
  def __repr__(self):
23059 
    L = ['%s=%r' % (key, value)
23060 
      for key, value in self.__dict__.iteritems()]
23061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23062 
 
23063 
  def __eq__(self, other):
23064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23065 
 
23066 
  def __ne__(self, other):
23067 
    return not (self == other)
23068 
 
5208 varun.gupt 23069 
class getRefundedOrdersMarkedPaid_args:
23070 
 
23071 
  thrift_spec = (
23072 
  )
23073 
 
23074 
  def read(self, iprot):
23075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23077 
      return
23078 
    iprot.readStructBegin()
23079 
    while True:
23080 
      (fname, ftype, fid) = iprot.readFieldBegin()
23081 
      if ftype == TType.STOP:
23082 
        break
23083 
      else:
23084 
        iprot.skip(ftype)
23085 
      iprot.readFieldEnd()
23086 
    iprot.readStructEnd()
23087 
 
23088 
  def write(self, oprot):
23089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23091 
      return
23092 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23093 
    oprot.writeFieldStop()
23094 
    oprot.writeStructEnd()
23095 
 
23096 
  def validate(self):
23097 
    return
23098 
 
23099 
 
23100 
  def __repr__(self):
23101 
    L = ['%s=%r' % (key, value)
23102 
      for key, value in self.__dict__.iteritems()]
23103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23104 
 
23105 
  def __eq__(self, other):
23106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23107 
 
23108 
  def __ne__(self, other):
23109 
    return not (self == other)
23110 
 
23111 
class getRefundedOrdersMarkedPaid_result:
23112 
  """
23113 
  Attributes:
23114 
   - success
23115 
   - ex
23116 
  """
23117 
 
23118 
  thrift_spec = (
23119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23121 
  )
23122 
 
23123 
  def __init__(self, success=None, ex=None,):
23124 
    self.success = success
23125 
    self.ex = ex
23126 
 
23127 
  def read(self, iprot):
23128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23130 
      return
23131 
    iprot.readStructBegin()
23132 
    while True:
23133 
      (fname, ftype, fid) = iprot.readFieldBegin()
23134 
      if ftype == TType.STOP:
23135 
        break
23136 
      if fid == 0:
23137 
        if ftype == TType.LIST:
23138 
          self.success = []
5481 phani.kuma 23139 
          (_etype553, _size550) = iprot.readListBegin()
23140 
          for _i554 in xrange(_size550):
23141 
            _elem555 = Order()
23142 
            _elem555.read(iprot)
23143 
            self.success.append(_elem555)
5208 varun.gupt 23144 
          iprot.readListEnd()
23145 
        else:
23146 
          iprot.skip(ftype)
23147 
      elif fid == 1:
23148 
        if ftype == TType.STRUCT:
23149 
          self.ex = TransactionServiceException()
23150 
          self.ex.read(iprot)
23151 
        else:
23152 
          iprot.skip(ftype)
23153 
      else:
23154 
        iprot.skip(ftype)
23155 
      iprot.readFieldEnd()
23156 
    iprot.readStructEnd()
23157 
 
23158 
  def write(self, oprot):
23159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23161 
      return
23162 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
23163 
    if self.success is not None:
23164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23166 
      for iter556 in self.success:
23167 
        iter556.write(oprot)
5208 varun.gupt 23168 
      oprot.writeListEnd()
23169 
      oprot.writeFieldEnd()
23170 
    if self.ex is not None:
23171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23172 
      self.ex.write(oprot)
23173 
      oprot.writeFieldEnd()
23174 
    oprot.writeFieldStop()
23175 
    oprot.writeStructEnd()
23176 
 
23177 
  def validate(self):
23178 
    return
23179 
 
23180 
 
23181 
  def __repr__(self):
23182 
    L = ['%s=%r' % (key, value)
23183 
      for key, value in self.__dict__.iteritems()]
23184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23185 
 
23186 
  def __eq__(self, other):
23187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23188 
 
23189 
  def __ne__(self, other):
23190 
    return not (self == other)
5447 anupam.sin 23191 
 
23192 
class getAllVerificationAgents_args:
23193 
  """
23194 
  Attributes:
23195 
   - minOrderId
23196 
   - maxOrderId
23197 
  """
23198 
 
23199 
  thrift_spec = (
23200 
    None, # 0
23201 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
23202 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
23203 
  )
23204 
 
23205 
  def __init__(self, minOrderId=None, maxOrderId=None,):
23206 
    self.minOrderId = minOrderId
23207 
    self.maxOrderId = maxOrderId
23208 
 
23209 
  def read(self, iprot):
23210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23212 
      return
23213 
    iprot.readStructBegin()
23214 
    while True:
23215 
      (fname, ftype, fid) = iprot.readFieldBegin()
23216 
      if ftype == TType.STOP:
23217 
        break
23218 
      if fid == 1:
23219 
        if ftype == TType.I64:
23220 
          self.minOrderId = iprot.readI64();
23221 
        else:
23222 
          iprot.skip(ftype)
23223 
      elif fid == 2:
23224 
        if ftype == TType.I64:
23225 
          self.maxOrderId = iprot.readI64();
23226 
        else:
23227 
          iprot.skip(ftype)
23228 
      else:
23229 
        iprot.skip(ftype)
23230 
      iprot.readFieldEnd()
23231 
    iprot.readStructEnd()
23232 
 
23233 
  def write(self, oprot):
23234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23236 
      return
23237 
    oprot.writeStructBegin('getAllVerificationAgents_args')
23238 
    if self.minOrderId is not None:
23239 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
23240 
      oprot.writeI64(self.minOrderId)
23241 
      oprot.writeFieldEnd()
23242 
    if self.maxOrderId is not None:
23243 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
23244 
      oprot.writeI64(self.maxOrderId)
23245 
      oprot.writeFieldEnd()
23246 
    oprot.writeFieldStop()
23247 
    oprot.writeStructEnd()
23248 
 
23249 
  def validate(self):
23250 
    return
23251 
 
23252 
 
23253 
  def __repr__(self):
23254 
    L = ['%s=%r' % (key, value)
23255 
      for key, value in self.__dict__.iteritems()]
23256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23257 
 
23258 
  def __eq__(self, other):
23259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23260 
 
23261 
  def __ne__(self, other):
23262 
    return not (self == other)
23263 
 
23264 
class getAllVerificationAgents_result:
23265 
  """
23266 
  Attributes:
23267 
   - success
23268 
  """
23269 
 
23270 
  thrift_spec = (
23271 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
23272 
  )
23273 
 
23274 
  def __init__(self, success=None,):
23275 
    self.success = success
23276 
 
23277 
  def read(self, iprot):
23278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23280 
      return
23281 
    iprot.readStructBegin()
23282 
    while True:
23283 
      (fname, ftype, fid) = iprot.readFieldBegin()
23284 
      if ftype == TType.STOP:
23285 
        break
23286 
      if fid == 0:
23287 
        if ftype == TType.LIST:
23288 
          self.success = []
5481 phani.kuma 23289 
          (_etype560, _size557) = iprot.readListBegin()
23290 
          for _i561 in xrange(_size557):
23291 
            _elem562 = CODVerificationAgent()
23292 
            _elem562.read(iprot)
23293 
            self.success.append(_elem562)
5447 anupam.sin 23294 
          iprot.readListEnd()
23295 
        else:
23296 
          iprot.skip(ftype)
23297 
      else:
23298 
        iprot.skip(ftype)
23299 
      iprot.readFieldEnd()
23300 
    iprot.readStructEnd()
23301 
 
23302 
  def write(self, oprot):
23303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23305 
      return
23306 
    oprot.writeStructBegin('getAllVerificationAgents_result')
23307 
    if self.success is not None:
23308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5481 phani.kuma 23310 
      for iter563 in self.success:
23311 
        iter563.write(oprot)
5447 anupam.sin 23312 
      oprot.writeListEnd()
23313 
      oprot.writeFieldEnd()
23314 
    oprot.writeFieldStop()
23315 
    oprot.writeStructEnd()
23316 
 
23317 
  def validate(self):
23318 
    return
23319 
 
23320 
 
23321 
  def __repr__(self):
23322 
    L = ['%s=%r' % (key, value)
23323 
      for key, value in self.__dict__.iteritems()]
23324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23325 
 
23326 
  def __eq__(self, other):
23327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23328 
 
23329 
  def __ne__(self, other):
23330 
    return not (self == other)