Subversion Repositories SmartDukaan

Rev

Rev 5411 | Rev 5481 | 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 
 
2700 chandransh 734 
  def getReturnOrder(self, id):
735 
    """
736 
    Returns the ReturnOrder corresponding to the given id.
737 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 738 
 
2700 chandransh 739 
    Parameters:
740 
     - id
741 
    """
742 
    pass
743 
 
2690 chandransh 744 
  def processReturn(self, returnOrderId):
745 
    """
746 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - returnOrderId
750 
    """
751 
    pass
752 
 
3451 chandransh 753 
  def updateWeight(self, orderId, weight):
754 
    """
755 
    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 756 
 
3451 chandransh 757 
    Parameters:
758 
     - orderId
759 
     - weight
760 
    """
761 
    pass
762 
 
3469 chandransh 763 
  def changeItem(self, orderId, itemId):
764 
    """
765 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
766 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 767 
 
3469 chandransh 768 
    Parameters:
769 
     - orderId
770 
     - itemId
771 
    """
772 
    pass
773 
 
774 
  def shiftToWarehouse(self, orderId, warehouseId):
775 
    """
776 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
777 
 
778 
    Parameters:
779 
     - orderId
780 
     - warehouseId
781 
    """
782 
    pass
783 
 
4647 rajveer 784 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 785 
    """
786 
    Adds the given delay reason to the given order.
3986 chandransh 787 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 788 
    Raises an exception if no order with the given id can be found.
3469 chandransh 789 
 
3553 chandransh 790 
    Parameters:
791 
     - orderId
792 
     - delayReason
3986 chandransh 793 
     - furtherDelay
4647 rajveer 794 
     - delayReasonText
3553 chandransh 795 
    """
796 
    pass
797 
 
3956 chandransh 798 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
799 
    """
800 
    Marks the COD orders with given AWB nos. as having been processed.
801 
    Updates the captured amount for the corresponding payment.
3553 chandransh 802 
 
3956 chandransh 803 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
804 
    1. There is no order corresponding to an AWB number.
805 
    2. The captured amount for a payment exceeds the total payment.
806 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
807 
 
808 
    Parameters:
809 
     - collectedAmountMap
810 
     - xferBy
811 
     - xferTxnId
812 
     - xferDate
813 
    """
814 
    pass
815 
 
4008 mandeep.dh 816 
  def getTransactionsRequiringExtraProcessing(self, category):
817 
    """
4065 mandeep.dh 818 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 819 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 820 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 821 
 
4008 mandeep.dh 822 
    Parameters:
823 
     - category
824 
    """
825 
    pass
826 
 
827 
  def markTransactionAsProcessed(self, transactionId, category):
828 
    """
829 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 830 
    It essentially deletes the transaction id record for a particular
831 
    processing type category (if present) from DB.
832 
    This is currently used by CRM application.
4008 mandeep.dh 833 
 
834 
    Parameters:
835 
     - transactionId
836 
     - category
837 
    """
838 
    pass
839 
 
4018 chandransh 840 
  def getItemWiseRiskyOrdersCount(self, ):
841 
    """
842 
    Returns a map containing the number of risky orders keyed by item id. A risky order
843 
    is defined as one whose shipping date is about to expire.
844 
    """
845 
    pass
4008 mandeep.dh 846 
 
4295 varun.gupt 847 
  def getOrdersForItemIds(self, itemIds):
848 
    """
849 
    Returns a list of all orders which have items with given id
850 
 
851 
    Parameters:
852 
     - itemIds
853 
    """
854 
    pass
855 
 
4247 rajveer 856 
  def markOrderCancellationRequestReceived(self, orderId):
857 
    """
858 
    Mark order as cancellation request received. If customer sends request of cancellation of
859 
    a particular order, this method will be called. It will just change status of the order
860 
    depending on its current status. It also records the previous status, so that we can move
861 
    back to that status if cancellation request is denied.
4018 chandransh 862 
 
4247 rajveer 863 
    Parameters:
864 
     - orderId
865 
    """
866 
    pass
867 
 
868 
  def markOrderCancellationRequestConfirmed(self, orderId):
869 
    """
870 
    If we decide to to cancel order, CRM will call this method to move the status of order to
871 
    cancellation request confirmed. After this OM will be able to cancel the order.
872 
 
873 
    Parameters:
874 
     - orderId
875 
    """
876 
    pass
877 
 
878 
  def markOrderCancellationRequestDenied(self, orderId):
879 
    """
880 
    If we decide to not to cancel order, we will move the order ro previous status.
881 
 
882 
    Parameters:
883 
     - orderId
884 
    """
885 
    pass
886 
 
4258 rajveer 887 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 888 
    """
4258 rajveer 889 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
890 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 891 
 
892 
    Parameters:
4258 rajveer 893 
     - transactionId
4247 rajveer 894 
    """
895 
    pass
896 
 
4259 anupam.sin 897 
  def refundTransaction(self, transactionId, refundedBy, reason):
898 
    """
899 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
900 
    need to be cancelled
4247 rajveer 901 
 
4259 anupam.sin 902 
    Parameters:
903 
     - transactionId
904 
     - refundedBy
905 
     - reason
906 
    """
907 
    pass
908 
 
4324 mandeep.dh 909 
  def updateShipmentAddress(self, orderId, addressId):
910 
    """
911 
    Updates shipment address of an order. Delivery and shipping date estimates
912 
    etc. are also updated here.
913 
 
914 
    Throws TransactionServiceException in case address change is not
915 
    possible due to certain reasons such as new pincode in address is
916 
    not serviceable etc.
917 
 
918 
    Parameters:
919 
     - orderId
920 
     - addressId
921 
    """
922 
    pass
923 
 
4285 rajveer 924 
  def acceptOrdersForItemId(self, itemId, inventory):
925 
    """
926 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
927 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 928 
 
4285 rajveer 929 
    Parameters:
930 
     - itemId
931 
     - inventory
932 
    """
933 
    pass
934 
 
4369 rajveer 935 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 936 
    """
937 
    Parameters:
938 
     - vendorId
939 
     - itemId
940 
     - quantity
941 
     - estimate
4369 rajveer 942 
     - isReminder
4303 rajveer 943 
    """
944 
    pass
4285 rajveer 945 
 
4369 rajveer 946 
  def markOrdersAsReversalInitiated(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
956 
 
4369 rajveer 957 
  def markOrdersAsNotAvailabke(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 markOrdersAsTimeout(self, vendorId):
969 
    """
970 
    Parameters:
971 
     - vendorId
972 
    """
973 
    pass
4303 rajveer 974 
 
4662 rajveer 975 
  def markOrderAsLostInTransit(self, orderId):
976 
    """
977 
    Mark order as LOST_IN_TRANSIT
978 
 
979 
    Parameters:
980 
     - orderId
981 
    """
982 
    pass
983 
 
4386 anupam.sin 984 
  def getOrderForAwb(self, awb):
985 
    """
986 
    Returns the order corresponding to an AWB number
4369 rajveer 987 
 
4386 anupam.sin 988 
    Parameters:
989 
     - awb
990 
    """
991 
    pass
992 
 
4910 phani.kuma 993 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 994 
    """
4910 phani.kuma 995 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 996 
 
4506 phani.kuma 997 
    Parameters:
998 
     - logistics_provider_id
4910 phani.kuma 999 
     - order_status_list
4506 phani.kuma 1000 
    """
1001 
    pass
1002 
 
4600 varun.gupt 1003 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1004 
    """
1005 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1006 
 
4600 varun.gupt 1007 
    Parameters:
1008 
     - vendorId
1009 
     - billingDateFrom
1010 
     - billingDateTo
1011 
    """
1012 
    pass
1013 
 
4607 rajveer 1014 
  def getSlippedSippingDateOrders(self, ):
1015 
    pass
1016 
 
4709 rajveer 1017 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1018 
    """
1019 
    Parameters:
1020 
     - cancelDateFrom
1021 
     - cancelDateTo
1022 
    """
1023 
    pass
1024 
 
4600 varun.gupt 1025 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1026 
    """
1027 
    Parameters:
1028 
     - mapAWBAndAmount
1029 
    """
1030 
    pass
1031 
 
4905 varun.gupt 1032 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1033 
    """
1034 
    Parameters:
1035 
     - settlementDate
1036 
     - paymentGatewayId
4905 varun.gupt 1037 
     - referenceId
4600 varun.gupt 1038 
     - serviceTax
1039 
     - otherCharges
1040 
     - netCollection
1041 
    """
1042 
    pass
1043 
 
1044 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1045 
    """
1046 
    Parameters:
1047 
     - settlementId
1048 
     - settlementDate
1049 
     - transactionDateFrom
1050 
     - transactionDateTo
1051 
     - amount
1052 
    """
1053 
    pass
1054 
 
5386 phani.kuma 1055 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1056 
    """
1057 
    Parameters:
5189 varun.gupt 1058 
     - referenceId
1059 
     - isRefund
4600 varun.gupt 1060 
    """
1061 
    pass
1062 
 
5386 phani.kuma 1063 
  def getSettlementForCod(self, orderId, isRefund):
1064 
    """
1065 
    Parameters:
1066 
     - orderId
1067 
     - isRefund
1068 
    """
1069 
    pass
1070 
 
4600 varun.gupt 1071 
  def getEBSSettlementSummaries(self, ):
1072 
    pass
1073 
 
1074 
  def markEBSSettlementUploaded(self, settlementId):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
    """
1079 
    pass
1080 
 
1081 
  def getEBSSettlementDate(self, settlementId):
1082 
    """
1083 
    Parameters:
1084 
     - settlementId
1085 
    """
1086 
    pass
1087 
 
4715 varun.gupt 1088 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1089 
    """
1090 
    Parameters:
1091 
     - settlementDateFrom
1092 
     - settlementDateTo
1093 
     - isRefund
1094 
    """
1095 
    pass
4600 varun.gupt 1096 
 
4715 varun.gupt 1097 
  def getReshippedOrderIds(self, orderIds):
1098 
    """
1099 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1100 
 
1101 
    Parameters:
1102 
     - orderIds
1103 
    """
1104 
    pass
1105 
 
4875 varun.gupt 1106 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1107 
    """
1108 
    Parameters:
1109 
     - vendorId
1110 
    """
1111 
    pass
4757 mandeep.dh 1112 
 
5031 varun.gupt 1113 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1114 
    """
1115 
    Parameters:
1116 
     - startDate
1117 
     - endDate
1118 
    """
1119 
    pass
4875 varun.gupt 1120 
 
5067 varun.gupt 1121 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1122 
    """
1123 
    Parameters:
1124 
     - status
1125 
     - startDatetime
1126 
     - endDatetime
1127 
    """
1128 
    pass
5031 varun.gupt 1129 
 
5348 anupam.sin 1130 
  def updateCODAgent(self, agent, orderId):
1131 
    """
1132 
    Updates the agent who handled the COD verification call
1133 
 
1134 
    Parameters:
1135 
     - agent
1136 
     - orderId
1137 
    """
1138 
    pass
1139 
 
5099 varun.gupt 1140 
  def updateOrderAsPaidToVendor(self, orderId):
1141 
    """
1142 
    Parameters:
1143 
     - orderId
1144 
    """
1145 
    pass
5067 varun.gupt 1146 
 
5386 phani.kuma 1147 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1148 
    """
1149 
    Parameters:
1150 
     - orderId
1151 
    """
1152 
    pass
1153 
 
5208 varun.gupt 1154 
  def getRefundedOrdersMarkedPaid(self, ):
1155 
    pass
5099 varun.gupt 1156 
 
5447 anupam.sin 1157 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1158 
    """
1159 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1160 
 
5447 anupam.sin 1161 
 
1162 
    Parameters:
1163 
     - minOrderId
1164 
     - maxOrderId
1165 
    """
1166 
    pass
1167 
 
1168 
 
3376 rajveer 1169 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1170 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1171 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1172 
 
1173 
  def createTransaction(self, transaction):
1174 
    """
1175 
    Parameters:
1176 
     - transaction
1177 
    """
1178 
    self.send_createTransaction(transaction)
132 ashish 1179 
    return self.recv_createTransaction()
94 ashish 1180 
 
1181 
  def send_createTransaction(self, transaction):
1182 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1183 
    args = createTransaction_args()
1184 
    args.transaction = transaction
1185 
    args.write(self._oprot)
1186 
    self._oprot.writeMessageEnd()
1187 
    self._oprot.trans.flush()
1188 
 
1189 
  def recv_createTransaction(self, ):
1190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1191 
    if mtype == TMessageType.EXCEPTION:
1192 
      x = TApplicationException()
1193 
      x.read(self._iprot)
1194 
      self._iprot.readMessageEnd()
1195 
      raise x
1196 
    result = createTransaction_result()
1197 
    result.read(self._iprot)
1198 
    self._iprot.readMessageEnd()
3431 rajveer 1199 
    if result.success is not None:
132 ashish 1200 
      return result.success
3431 rajveer 1201 
    if result.ex is not None:
94 ashish 1202 
      raise result.ex
132 ashish 1203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1204 
 
1205 
  def getTransaction(self, id):
1206 
    """
1207 
    Parameters:
1208 
     - id
1209 
    """
1210 
    self.send_getTransaction(id)
1211 
    return self.recv_getTransaction()
1212 
 
1213 
  def send_getTransaction(self, id):
1214 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1215 
    args = getTransaction_args()
1216 
    args.id = id
1217 
    args.write(self._oprot)
1218 
    self._oprot.writeMessageEnd()
1219 
    self._oprot.trans.flush()
1220 
 
1221 
  def recv_getTransaction(self, ):
1222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1223 
    if mtype == TMessageType.EXCEPTION:
1224 
      x = TApplicationException()
1225 
      x.read(self._iprot)
1226 
      self._iprot.readMessageEnd()
1227 
      raise x
1228 
    result = getTransaction_result()
1229 
    result.read(self._iprot)
1230 
    self._iprot.readMessageEnd()
3431 rajveer 1231 
    if result.success is not None:
94 ashish 1232 
      return result.success
3431 rajveer 1233 
    if result.ex is not None:
94 ashish 1234 
      raise result.ex
1235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1236 
 
1237 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1238 
    """
1239 
    Parameters:
1240 
     - customerId
1241 
     - from_date
1242 
     - to_date
1243 
     - status
1244 
    """
1245 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1246 
    return self.recv_getTransactionsForCustomer()
1247 
 
1248 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1249 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1250 
    args = getTransactionsForCustomer_args()
1251 
    args.customerId = customerId
1252 
    args.from_date = from_date
1253 
    args.to_date = to_date
1254 
    args.status = status
1255 
    args.write(self._oprot)
1256 
    self._oprot.writeMessageEnd()
1257 
    self._oprot.trans.flush()
1258 
 
1259 
  def recv_getTransactionsForCustomer(self, ):
1260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1261 
    if mtype == TMessageType.EXCEPTION:
1262 
      x = TApplicationException()
1263 
      x.read(self._iprot)
1264 
      self._iprot.readMessageEnd()
1265 
      raise x
1266 
    result = getTransactionsForCustomer_result()
1267 
    result.read(self._iprot)
1268 
    self._iprot.readMessageEnd()
3431 rajveer 1269 
    if result.success is not None:
94 ashish 1270 
      return result.success
3431 rajveer 1271 
    if result.ex is not None:
94 ashish 1272 
      raise result.ex
1273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1274 
 
132 ashish 1275 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1276 
    """
1277 
    Parameters:
1278 
     - shoppingCartId
1279 
    """
1280 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1281 
    return self.recv_getTransactionsForShoppingCartId()
1282 
 
1283 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1284 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1285 
    args = getTransactionsForShoppingCartId_args()
1286 
    args.shoppingCartId = shoppingCartId
1287 
    args.write(self._oprot)
1288 
    self._oprot.writeMessageEnd()
1289 
    self._oprot.trans.flush()
1290 
 
1291 
  def recv_getTransactionsForShoppingCartId(self, ):
1292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1293 
    if mtype == TMessageType.EXCEPTION:
1294 
      x = TApplicationException()
1295 
      x.read(self._iprot)
1296 
      self._iprot.readMessageEnd()
1297 
      raise x
1298 
    result = getTransactionsForShoppingCartId_result()
1299 
    result.read(self._iprot)
1300 
    self._iprot.readMessageEnd()
3431 rajveer 1301 
    if result.success is not None:
132 ashish 1302 
      return result.success
3431 rajveer 1303 
    if result.ex is not None:
132 ashish 1304 
      raise result.ex
1305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1306 
 
94 ashish 1307 
  def getTransactionStatus(self, transactionId):
1308 
    """
1309 
    Parameters:
1310 
     - transactionId
1311 
    """
1312 
    self.send_getTransactionStatus(transactionId)
1313 
    return self.recv_getTransactionStatus()
1314 
 
1315 
  def send_getTransactionStatus(self, transactionId):
1316 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1317 
    args = getTransactionStatus_args()
1318 
    args.transactionId = transactionId
1319 
    args.write(self._oprot)
1320 
    self._oprot.writeMessageEnd()
1321 
    self._oprot.trans.flush()
1322 
 
1323 
  def recv_getTransactionStatus(self, ):
1324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1325 
    if mtype == TMessageType.EXCEPTION:
1326 
      x = TApplicationException()
1327 
      x.read(self._iprot)
1328 
      self._iprot.readMessageEnd()
1329 
      raise x
1330 
    result = getTransactionStatus_result()
1331 
    result.read(self._iprot)
1332 
    self._iprot.readMessageEnd()
3431 rajveer 1333 
    if result.success is not None:
94 ashish 1334 
      return result.success
3431 rajveer 1335 
    if result.ex is not None:
94 ashish 1336 
      raise result.ex
1337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1338 
 
5387 rajveer 1339 
  def changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 1340 
    """
1341 
    Parameters:
1342 
     - transactionId
1343 
     - status
1344 
     - description
5387 rajveer 1345 
     - selfPickup
94 ashish 1346 
    """
5387 rajveer 1347 
    self.send_changeTransactionStatus(transactionId, status, description, selfPickup)
94 ashish 1348 
    return self.recv_changeTransactionStatus()
1349 
 
5387 rajveer 1350 
  def send_changeTransactionStatus(self, transactionId, status, description, selfPickup):
94 ashish 1351 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1352 
    args = changeTransactionStatus_args()
1353 
    args.transactionId = transactionId
1354 
    args.status = status
1355 
    args.description = description
5387 rajveer 1356 
    args.selfPickup = selfPickup
94 ashish 1357 
    args.write(self._oprot)
1358 
    self._oprot.writeMessageEnd()
1359 
    self._oprot.trans.flush()
1360 
 
1361 
  def recv_changeTransactionStatus(self, ):
1362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1363 
    if mtype == TMessageType.EXCEPTION:
1364 
      x = TApplicationException()
1365 
      x.read(self._iprot)
1366 
      self._iprot.readMessageEnd()
1367 
      raise x
1368 
    result = changeTransactionStatus_result()
1369 
    result.read(self._iprot)
1370 
    self._iprot.readMessageEnd()
3431 rajveer 1371 
    if result.success is not None:
94 ashish 1372 
      return result.success
3431 rajveer 1373 
    if result.ex is not None:
94 ashish 1374 
      raise result.ex
1375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1376 
 
1398 varun.gupt 1377 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1378 
    """
1379 
    Parameters:
1380 
     - transactionId
1381 
    """
1398 varun.gupt 1382 
    self.send_enqueueTransactionInfoEmail(transactionId)
1383 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1384 
 
1398 varun.gupt 1385 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1386 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1387 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1388 
    args.transactionId = transactionId
1389 
    args.write(self._oprot)
1390 
    self._oprot.writeMessageEnd()
1391 
    self._oprot.trans.flush()
1392 
 
1398 varun.gupt 1393 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1395 
    if mtype == TMessageType.EXCEPTION:
1396 
      x = TApplicationException()
1397 
      x.read(self._iprot)
1398 
      self._iprot.readMessageEnd()
1399 
      raise x
1398 varun.gupt 1400 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1401 
    result.read(self._iprot)
1402 
    self._iprot.readMessageEnd()
3431 rajveer 1403 
    if result.success is not None:
1382 varun.gupt 1404 
      return result.success
3431 rajveer 1405 
    if result.ex is not None:
1382 varun.gupt 1406 
      raise result.ex
1398 varun.gupt 1407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1408 
 
4801 anupam.sin 1409 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1410 
    """
1411 
    Parameters:
4801 anupam.sin 1412 
     - statuses
483 rajveer 1413 
     - from_date
1414 
     - to_date
1415 
     - warehouse_id
94 ashish 1416 
    """
4801 anupam.sin 1417 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1418 
    return self.recv_getAllOrders()
94 ashish 1419 
 
4801 anupam.sin 1420 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1421 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1422 
    args = getAllOrders_args()
4801 anupam.sin 1423 
    args.statuses = statuses
483 rajveer 1424 
    args.from_date = from_date
1425 
    args.to_date = to_date
1426 
    args.warehouse_id = warehouse_id
94 ashish 1427 
    args.write(self._oprot)
1428 
    self._oprot.writeMessageEnd()
1429 
    self._oprot.trans.flush()
1430 
 
483 rajveer 1431 
  def recv_getAllOrders(self, ):
94 ashish 1432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1433 
    if mtype == TMessageType.EXCEPTION:
1434 
      x = TApplicationException()
1435 
      x.read(self._iprot)
1436 
      self._iprot.readMessageEnd()
1437 
      raise x
483 rajveer 1438 
    result = getAllOrders_result()
94 ashish 1439 
    result.read(self._iprot)
1440 
    self._iprot.readMessageEnd()
3431 rajveer 1441 
    if result.success is not None:
94 ashish 1442 
      return result.success
3431 rajveer 1443 
    if result.ex is not None:
94 ashish 1444 
      raise result.ex
483 rajveer 1445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1446 
 
4133 chandransh 1447 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1448 
    """
1449 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1450 
    Pass the status as null and the limit as 0 to ignore them.
1451 
 
1452 
    Parameters:
1453 
     - statuses
1454 
     - offset
1455 
     - limit
1456 
     - warehouse_id
1457 
    """
1458 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1459 
    return self.recv_getOrdersInBatch()
1460 
 
1461 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1462 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1463 
    args = getOrdersInBatch_args()
1464 
    args.statuses = statuses
1465 
    args.offset = offset
1466 
    args.limit = limit
1467 
    args.warehouse_id = warehouse_id
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getOrdersInBatch(self, ):
1473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1474 
    if mtype == TMessageType.EXCEPTION:
1475 
      x = TApplicationException()
1476 
      x.read(self._iprot)
1477 
      self._iprot.readMessageEnd()
1478 
      raise x
1479 
    result = getOrdersInBatch_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
1482 
    if result.success is not None:
1483 
      return result.success
1484 
    if result.ex is not None:
1485 
      raise result.ex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1487 
 
1488 
  def getOrderCount(self, statuses, warehouseId):
1489 
    """
1490 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1491 
 
1492 
    Parameters:
1493 
     - statuses
1494 
     - warehouseId
1495 
    """
1496 
    self.send_getOrderCount(statuses, warehouseId)
1497 
    return self.recv_getOrderCount()
1498 
 
1499 
  def send_getOrderCount(self, statuses, warehouseId):
1500 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1501 
    args = getOrderCount_args()
1502 
    args.statuses = statuses
1503 
    args.warehouseId = warehouseId
1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
1508 
  def recv_getOrderCount(self, ):
1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
1515 
    result = getOrderCount_result()
1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
1518 
    if result.success is not None:
1519 
      return result.success
1520 
    if result.ex is not None:
1521 
      raise result.ex
1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1523 
 
999 varun.gupt 1524 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1525 
    """
1132 chandransh 1526 
    Returns orders within a range of their billing dates
3431 rajveer 1527 
 
999 varun.gupt 1528 
    Parameters:
1529 
     - status
1530 
     - start_billing_date
1531 
     - end_billing_date
1532 
     - warehouse_id
1533 
    """
1534 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1535 
    return self.recv_getOrdersByBillingDate()
1536 
 
1537 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1538 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1539 
    args = getOrdersByBillingDate_args()
1540 
    args.status = status
1541 
    args.start_billing_date = start_billing_date
1542 
    args.end_billing_date = end_billing_date
1543 
    args.warehouse_id = warehouse_id
1544 
    args.write(self._oprot)
1545 
    self._oprot.writeMessageEnd()
1546 
    self._oprot.trans.flush()
1547 
 
1548 
  def recv_getOrdersByBillingDate(self, ):
1549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1550 
    if mtype == TMessageType.EXCEPTION:
1551 
      x = TApplicationException()
1552 
      x.read(self._iprot)
1553 
      self._iprot.readMessageEnd()
1554 
      raise x
1555 
    result = getOrdersByBillingDate_result()
1556 
    result.read(self._iprot)
1557 
    self._iprot.readMessageEnd()
3431 rajveer 1558 
    if result.success is not None:
999 varun.gupt 1559 
      return result.success
3431 rajveer 1560 
    if result.ex is not None:
999 varun.gupt 1561 
      raise result.ex
1562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1563 
 
3451 chandransh 1564 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1565 
    """
1566 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1567 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1568 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1569 
 
3427 chandransh 1570 
    Parameters:
1571 
     - fromShippingDate
1572 
     - toShippingDate
1573 
     - providerId
1574 
     - warehouseId
3451 chandransh 1575 
     - cod
3427 chandransh 1576 
    """
3451 chandransh 1577 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1578 
    return self.recv_getOrdersByShippingDate()
1579 
 
3451 chandransh 1580 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1581 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1582 
    args = getOrdersByShippingDate_args()
1583 
    args.fromShippingDate = fromShippingDate
1584 
    args.toShippingDate = toShippingDate
1585 
    args.providerId = providerId
1586 
    args.warehouseId = warehouseId
3451 chandransh 1587 
    args.cod = cod
3427 chandransh 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
1592 
  def recv_getOrdersByShippingDate(self, ):
1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
1599 
    result = getOrdersByShippingDate_result()
1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
3427 chandransh 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
3427 chandransh 1605 
      raise result.ex
1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1607 
 
1382 varun.gupt 1608 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1609 
    """
1610 
    Returns order ids for orders which can be returned
3431 rajveer 1611 
 
1382 varun.gupt 1612 
    Parameters:
1613 
     - customer_id
1614 
     - limit
1615 
    """
1616 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1617 
    return self.recv_getReturnableOrdersForCustomer()
1618 
 
1619 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1620 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1621 
    args = getReturnableOrdersForCustomer_args()
1622 
    args.customer_id = customer_id
1623 
    args.limit = limit
1624 
    args.write(self._oprot)
1625 
    self._oprot.writeMessageEnd()
1626 
    self._oprot.trans.flush()
1627 
 
1628 
  def recv_getReturnableOrdersForCustomer(self, ):
1629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1630 
    if mtype == TMessageType.EXCEPTION:
1631 
      x = TApplicationException()
1632 
      x.read(self._iprot)
1633 
      self._iprot.readMessageEnd()
1634 
      raise x
1635 
    result = getReturnableOrdersForCustomer_result()
1636 
    result.read(self._iprot)
1637 
    self._iprot.readMessageEnd()
3431 rajveer 1638 
    if result.success is not None:
1382 varun.gupt 1639 
      return result.success
3431 rajveer 1640 
    if result.ex is not None:
1382 varun.gupt 1641 
      raise result.ex
1642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1643 
 
1644 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1645 
    """
1646 
    Returns order ids for orders which can be cancelled
3431 rajveer 1647 
 
1382 varun.gupt 1648 
    Parameters:
1649 
     - customer_id
1650 
     - limit
1651 
    """
1652 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1653 
    return self.recv_getCancellableOrdersForCustomer()
1654 
 
1655 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1656 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1657 
    args = getCancellableOrdersForCustomer_args()
1658 
    args.customer_id = customer_id
1659 
    args.limit = limit
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getCancellableOrdersForCustomer(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getCancellableOrdersForCustomer_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
3431 rajveer 1674 
    if result.success is not None:
1382 varun.gupt 1675 
      return result.success
3431 rajveer 1676 
    if result.ex is not None:
1382 varun.gupt 1677 
      raise result.ex
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1679 
 
483 rajveer 1680 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1681 
    """
1682 
    Parameters:
483 rajveer 1683 
     - orderId
1684 
     - status
1685 
     - description
94 ashish 1686 
    """
483 rajveer 1687 
    self.send_changeOrderStatus(orderId, status, description)
1688 
    return self.recv_changeOrderStatus()
94 ashish 1689 
 
483 rajveer 1690 
  def send_changeOrderStatus(self, orderId, status, description):
1691 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1692 
    args = changeOrderStatus_args()
1693 
    args.orderId = orderId
1694 
    args.status = status
1695 
    args.description = description
94 ashish 1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
483 rajveer 1700 
  def recv_changeOrderStatus(self, ):
94 ashish 1701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1702 
    if mtype == TMessageType.EXCEPTION:
1703 
      x = TApplicationException()
1704 
      x.read(self._iprot)
1705 
      self._iprot.readMessageEnd()
1706 
      raise x
483 rajveer 1707 
    result = changeOrderStatus_result()
94 ashish 1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
3431 rajveer 1710 
    if result.success is not None:
94 ashish 1711 
      return result.success
3431 rajveer 1712 
    if result.ex is not None:
94 ashish 1713 
      raise result.ex
483 rajveer 1714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1715 
 
1528 ankur.sing 1716 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1717 
    """
1528 ankur.sing 1718 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1719 
    only user who owns the transaction can view its order details.
3431 rajveer 1720 
 
94 ashish 1721 
    Parameters:
1722 
     - transactionId
1528 ankur.sing 1723 
     - customerId
94 ashish 1724 
    """
1528 ankur.sing 1725 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1726 
    return self.recv_getOrdersForTransaction()
94 ashish 1727 
 
1528 ankur.sing 1728 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1729 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1730 
    args = getOrdersForTransaction_args()
94 ashish 1731 
    args.transactionId = transactionId
1528 ankur.sing 1732 
    args.customerId = customerId
94 ashish 1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
483 rajveer 1737 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
483 rajveer 1744 
    result = getOrdersForTransaction_result()
94 ashish 1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
94 ashish 1748 
      return result.success
3431 rajveer 1749 
    if result.ex is not None:
94 ashish 1750 
      raise result.ex
483 rajveer 1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1752 
 
3014 chandransh 1753 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1754 
    """
3014 chandransh 1755 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1756 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1757 
 
94 ashish 1758 
    Parameters:
483 rajveer 1759 
     - customerId
1760 
     - from_date
1761 
     - to_date
3014 chandransh 1762 
     - statuses
94 ashish 1763 
    """
3014 chandransh 1764 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1765 
    return self.recv_getOrdersForCustomer()
94 ashish 1766 
 
3014 chandransh 1767 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1768 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1769 
    args = getOrdersForCustomer_args()
1770 
    args.customerId = customerId
1771 
    args.from_date = from_date
1772 
    args.to_date = to_date
3014 chandransh 1773 
    args.statuses = statuses
94 ashish 1774 
    args.write(self._oprot)
1775 
    self._oprot.writeMessageEnd()
1776 
    self._oprot.trans.flush()
1777 
 
483 rajveer 1778 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1780 
    if mtype == TMessageType.EXCEPTION:
1781 
      x = TApplicationException()
1782 
      x.read(self._iprot)
1783 
      self._iprot.readMessageEnd()
1784 
      raise x
483 rajveer 1785 
    result = getOrdersForCustomer_result()
94 ashish 1786 
    result.read(self._iprot)
1787 
    self._iprot.readMessageEnd()
3431 rajveer 1788 
    if result.success is not None:
94 ashish 1789 
      return result.success
3431 rajveer 1790 
    if result.ex is not None:
94 ashish 1791 
      raise result.ex
483 rajveer 1792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1793 
 
483 rajveer 1794 
  def createOrder(self, order):
94 ashish 1795 
    """
1796 
    Parameters:
483 rajveer 1797 
     - order
94 ashish 1798 
    """
483 rajveer 1799 
    self.send_createOrder(order)
1800 
    return self.recv_createOrder()
94 ashish 1801 
 
483 rajveer 1802 
  def send_createOrder(self, order):
1803 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1804 
    args = createOrder_args()
1805 
    args.order = order
94 ashish 1806 
    args.write(self._oprot)
1807 
    self._oprot.writeMessageEnd()
1808 
    self._oprot.trans.flush()
1809 
 
483 rajveer 1810 
  def recv_createOrder(self, ):
94 ashish 1811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1812 
    if mtype == TMessageType.EXCEPTION:
1813 
      x = TApplicationException()
1814 
      x.read(self._iprot)
1815 
      self._iprot.readMessageEnd()
1816 
      raise x
483 rajveer 1817 
    result = createOrder_result()
94 ashish 1818 
    result.read(self._iprot)
1819 
    self._iprot.readMessageEnd()
3431 rajveer 1820 
    if result.success is not None:
94 ashish 1821 
      return result.success
3431 rajveer 1822 
    if result.ex is not None:
94 ashish 1823 
      raise result.ex
483 rajveer 1824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1825 
 
483 rajveer 1826 
  def getOrder(self, id):
94 ashish 1827 
    """
1828 
    Parameters:
483 rajveer 1829 
     - id
94 ashish 1830 
    """
483 rajveer 1831 
    self.send_getOrder(id)
1832 
    return self.recv_getOrder()
94 ashish 1833 
 
483 rajveer 1834 
  def send_getOrder(self, id):
1835 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1836 
    args = getOrder_args()
1837 
    args.id = id
94 ashish 1838 
    args.write(self._oprot)
1839 
    self._oprot.writeMessageEnd()
1840 
    self._oprot.trans.flush()
1841 
 
483 rajveer 1842 
  def recv_getOrder(self, ):
94 ashish 1843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1844 
    if mtype == TMessageType.EXCEPTION:
1845 
      x = TApplicationException()
1846 
      x.read(self._iprot)
1847 
      self._iprot.readMessageEnd()
1848 
      raise x
483 rajveer 1849 
    result = getOrder_result()
94 ashish 1850 
    result.read(self._iprot)
1851 
    self._iprot.readMessageEnd()
3431 rajveer 1852 
    if result.success is not None:
94 ashish 1853 
      return result.success
3431 rajveer 1854 
    if result.ex is not None:
94 ashish 1855 
      raise result.ex
483 rajveer 1856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1857 
 
483 rajveer 1858 
  def getLineItemsForOrder(self, orderId):
94 ashish 1859 
    """
1860 
    Parameters:
483 rajveer 1861 
     - orderId
94 ashish 1862 
    """
483 rajveer 1863 
    self.send_getLineItemsForOrder(orderId)
1864 
    return self.recv_getLineItemsForOrder()
94 ashish 1865 
 
483 rajveer 1866 
  def send_getLineItemsForOrder(self, orderId):
1867 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1868 
    args = getLineItemsForOrder_args()
1869 
    args.orderId = orderId
94 ashish 1870 
    args.write(self._oprot)
1871 
    self._oprot.writeMessageEnd()
1872 
    self._oprot.trans.flush()
1873 
 
483 rajveer 1874 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1876 
    if mtype == TMessageType.EXCEPTION:
1877 
      x = TApplicationException()
1878 
      x.read(self._iprot)
1879 
      self._iprot.readMessageEnd()
1880 
      raise x
483 rajveer 1881 
    result = getLineItemsForOrder_result()
94 ashish 1882 
    result.read(self._iprot)
1883 
    self._iprot.readMessageEnd()
3431 rajveer 1884 
    if result.success is not None:
94 ashish 1885 
      return result.success
3431 rajveer 1886 
    if result.ex is not None:
94 ashish 1887 
      raise result.ex
483 rajveer 1888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1889 
 
4999 phani.kuma 1890 
  def getOrderList(self, order_ids):
1891 
    """
1892 
    Parameters:
1893 
     - order_ids
1894 
    """
1895 
    self.send_getOrderList(order_ids)
1896 
    return self.recv_getOrderList()
1897 
 
1898 
  def send_getOrderList(self, order_ids):
1899 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1900 
    args = getOrderList_args()
1901 
    args.order_ids = order_ids
1902 
    args.write(self._oprot)
1903 
    self._oprot.writeMessageEnd()
1904 
    self._oprot.trans.flush()
1905 
 
1906 
  def recv_getOrderList(self, ):
1907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1908 
    if mtype == TMessageType.EXCEPTION:
1909 
      x = TApplicationException()
1910 
      x.read(self._iprot)
1911 
      self._iprot.readMessageEnd()
1912 
      raise x
1913 
    result = getOrderList_result()
1914 
    result.read(self._iprot)
1915 
    self._iprot.readMessageEnd()
1916 
    if result.success is not None:
1917 
      return result.success
1918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1919 
 
5386 phani.kuma 1920 
  def getOrderListForVendor(self, order_ids, vendorId):
1921 
    """
1922 
    Parameters:
1923 
     - order_ids
1924 
     - vendorId
1925 
    """
1926 
    self.send_getOrderListForVendor(order_ids, vendorId)
1927 
    return self.recv_getOrderListForVendor()
1928 
 
1929 
  def send_getOrderListForVendor(self, order_ids, vendorId):
1930 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
1931 
    args = getOrderListForVendor_args()
1932 
    args.order_ids = order_ids
1933 
    args.vendorId = vendorId
1934 
    args.write(self._oprot)
1935 
    self._oprot.writeMessageEnd()
1936 
    self._oprot.trans.flush()
1937 
 
1938 
  def recv_getOrderListForVendor(self, ):
1939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1940 
    if mtype == TMessageType.EXCEPTION:
1941 
      x = TApplicationException()
1942 
      x.read(self._iprot)
1943 
      self._iprot.readMessageEnd()
1944 
      raise x
1945 
    result = getOrderListForVendor_result()
1946 
    result.read(self._iprot)
1947 
    self._iprot.readMessageEnd()
1948 
    if result.success is not None:
1949 
      return result.success
1950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
1951 
 
1528 ankur.sing 1952 
  def getOrderForCustomer(self, orderId, customerId):
1953 
    """
1954 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1955 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1956 
 
1528 ankur.sing 1957 
    Parameters:
1958 
     - orderId
1959 
     - customerId
1960 
    """
1961 
    self.send_getOrderForCustomer(orderId, customerId)
1962 
    return self.recv_getOrderForCustomer()
1963 
 
1964 
  def send_getOrderForCustomer(self, orderId, customerId):
1965 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1966 
    args = getOrderForCustomer_args()
1967 
    args.orderId = orderId
1968 
    args.customerId = customerId
1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1973 
  def recv_getOrderForCustomer(self, ):
1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1980 
    result = getOrderForCustomer_result()
1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
3431 rajveer 1983 
    if result.success is not None:
1528 ankur.sing 1984 
      return result.success
3431 rajveer 1985 
    if result.ex is not None:
1528 ankur.sing 1986 
      raise result.ex
1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1988 
 
4444 rajveer 1989 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1990 
    """
1991 
    Parameters:
4394 rajveer 1992 
     - type
4444 rajveer 1993 
     - warehouseId
4394 rajveer 1994 
     - status
1995 
     - timestamp
3064 chandransh 1996 
    """
4444 rajveer 1997 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1998 
    return self.recv_getAlerts()
1999 
 
4444 rajveer 2000 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2001 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2002 
    args = getAlerts_args()
4394 rajveer 2003 
    args.type = type
4444 rajveer 2004 
    args.warehouseId = warehouseId
4394 rajveer 2005 
    args.status = status
2006 
    args.timestamp = timestamp
3064 chandransh 2007 
    args.write(self._oprot)
2008 
    self._oprot.writeMessageEnd()
2009 
    self._oprot.trans.flush()
2010 
 
2011 
  def recv_getAlerts(self, ):
2012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2013 
    if mtype == TMessageType.EXCEPTION:
2014 
      x = TApplicationException()
2015 
      x.read(self._iprot)
2016 
      self._iprot.readMessageEnd()
2017 
      raise x
2018 
    result = getAlerts_result()
2019 
    result.read(self._iprot)
2020 
    self._iprot.readMessageEnd()
3431 rajveer 2021 
    if result.success is not None:
3064 chandransh 2022 
      return result.success
2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2024 
 
4444 rajveer 2025 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2026 
    """
2027 
    Parameters:
2028 
     - type
4444 rajveer 2029 
     - warehouseId
4394 rajveer 2030 
     - description
3064 chandransh 2031 
    """
4444 rajveer 2032 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2033 
    self.recv_addAlert()
3064 chandransh 2034 
 
4444 rajveer 2035 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2036 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2037 
    args = addAlert_args()
3064 chandransh 2038 
    args.type = type
4444 rajveer 2039 
    args.warehouseId = warehouseId
4394 rajveer 2040 
    args.description = description
3064 chandransh 2041 
    args.write(self._oprot)
2042 
    self._oprot.writeMessageEnd()
2043 
    self._oprot.trans.flush()
2044 
 
4394 rajveer 2045 
  def recv_addAlert(self, ):
3064 chandransh 2046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2047 
    if mtype == TMessageType.EXCEPTION:
2048 
      x = TApplicationException()
2049 
      x.read(self._iprot)
2050 
      self._iprot.readMessageEnd()
2051 
      raise x
4394 rajveer 2052 
    result = addAlert_result()
3064 chandransh 2053 
    result.read(self._iprot)
2054 
    self._iprot.readMessageEnd()
2055 
    return
2056 
 
4444 rajveer 2057 
  def markAlertsAsSeen(self, warehouseId):
2058 
    """
2059 
    Parameters:
2060 
     - warehouseId
2061 
    """
2062 
    self.send_markAlertsAsSeen(warehouseId)
2063 
    self.recv_markAlertsAsSeen()
2064 
 
2065 
  def send_markAlertsAsSeen(self, warehouseId):
2066 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2067 
    args = markAlertsAsSeen_args()
2068 
    args.warehouseId = warehouseId
2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
2073 
  def recv_markAlertsAsSeen(self, ):
2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
2080 
    result = markAlertsAsSeen_result()
2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
2083 
    return
2084 
 
3064 chandransh 2085 
  def getValidOrderCount(self, ):
2086 
    """
2087 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2088 
    """
2089 
    self.send_getValidOrderCount()
2090 
    return self.recv_getValidOrderCount()
2091 
 
2092 
  def send_getValidOrderCount(self, ):
2093 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2094 
    args = getValidOrderCount_args()
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_getValidOrderCount(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = getValidOrderCount_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
3431 rajveer 2109 
    if result.success is not None:
3064 chandransh 2110 
      return result.success
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2112 
 
2113 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2114 
    """
2115 
    Returns the number of distinct customers who have done successful transactions
2116 
    """
2117 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2118 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2119 
 
2120 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2121 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2122 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
2127 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
2134 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
3431 rajveer 2137 
    if result.success is not None:
3064 chandransh 2138 
      return result.success
2139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2140 
 
2141 
  def getValidOrdersAmountRange(self, ):
2142 
    """
2143 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2144 
    List contains two values, first minimum amount and second maximum amount.
2145 
    """
2146 
    self.send_getValidOrdersAmountRange()
2147 
    return self.recv_getValidOrdersAmountRange()
2148 
 
2149 
  def send_getValidOrdersAmountRange(self, ):
2150 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2151 
    args = getValidOrdersAmountRange_args()
2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
2156 
  def recv_getValidOrdersAmountRange(self, ):
2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
2163 
    result = getValidOrdersAmountRange_result()
2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
3431 rajveer 2166 
    if result.success is not None:
3064 chandransh 2167 
      return result.success
2168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2169 
 
2170 
  def getValidOrders(self, limit):
2171 
    """
2172 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2173 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2174 
 
3064 chandransh 2175 
    Parameters:
2176 
     - limit
2177 
    """
2178 
    self.send_getValidOrders(limit)
2179 
    return self.recv_getValidOrders()
2180 
 
2181 
  def send_getValidOrders(self, limit):
2182 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2183 
    args = getValidOrders_args()
2184 
    args.limit = limit
2185 
    args.write(self._oprot)
2186 
    self._oprot.writeMessageEnd()
2187 
    self._oprot.trans.flush()
2188 
 
2189 
  def recv_getValidOrders(self, ):
2190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2191 
    if mtype == TMessageType.EXCEPTION:
2192 
      x = TApplicationException()
2193 
      x.read(self._iprot)
2194 
      self._iprot.readMessageEnd()
2195 
      raise x
2196 
    result = getValidOrders_result()
2197 
    result.read(self._iprot)
2198 
    self._iprot.readMessageEnd()
3431 rajveer 2199 
    if result.success is not None:
3064 chandransh 2200 
      return result.success
2201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2202 
 
1220 chandransh 2203 
  def batchOrders(self, warehouseId):
2204 
    """
2205 
    Create a batch of all the pending orders for the given warehouse.
2206 
    The returned list is orderd by created_timestamp.
2207 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2208 
 
1220 chandransh 2209 
    Parameters:
2210 
     - warehouseId
2211 
    """
2212 
    self.send_batchOrders(warehouseId)
2213 
    return self.recv_batchOrders()
2214 
 
2215 
  def send_batchOrders(self, warehouseId):
2216 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2217 
    args = batchOrders_args()
2218 
    args.warehouseId = warehouseId
2219 
    args.write(self._oprot)
2220 
    self._oprot.writeMessageEnd()
2221 
    self._oprot.trans.flush()
2222 
 
2223 
  def recv_batchOrders(self, ):
2224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2225 
    if mtype == TMessageType.EXCEPTION:
2226 
      x = TApplicationException()
2227 
      x.read(self._iprot)
2228 
      self._iprot.readMessageEnd()
2229 
      raise x
2230 
    result = batchOrders_result()
2231 
    result.read(self._iprot)
2232 
    self._iprot.readMessageEnd()
3431 rajveer 2233 
    if result.success is not None:
1220 chandransh 2234 
      return result.success
3431 rajveer 2235 
    if result.ex is not None:
1220 chandransh 2236 
      raise result.ex
2237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2238 
 
1208 chandransh 2239 
  def markOrderAsOutOfStock(self, orderId):
2240 
    """
2241 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2242 
 
1208 chandransh 2243 
    Parameters:
2244 
     - orderId
2245 
    """
2246 
    self.send_markOrderAsOutOfStock(orderId)
2247 
    return self.recv_markOrderAsOutOfStock()
2248 
 
2249 
  def send_markOrderAsOutOfStock(self, orderId):
2250 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2251 
    args = markOrderAsOutOfStock_args()
2252 
    args.orderId = orderId
2253 
    args.write(self._oprot)
2254 
    self._oprot.writeMessageEnd()
2255 
    self._oprot.trans.flush()
2256 
 
2257 
  def recv_markOrderAsOutOfStock(self, ):
2258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2259 
    if mtype == TMessageType.EXCEPTION:
2260 
      x = TApplicationException()
2261 
      x.read(self._iprot)
2262 
      self._iprot.readMessageEnd()
2263 
      raise x
2264 
    result = markOrderAsOutOfStock_result()
2265 
    result.read(self._iprot)
2266 
    self._iprot.readMessageEnd()
3431 rajveer 2267 
    if result.success is not None:
1208 chandransh 2268 
      return result.success
3431 rajveer 2269 
    if result.ex is not None:
1208 chandransh 2270 
      raise result.ex
2271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2272 
 
3064 chandransh 2273 
  def verifyOrder(self, orderId):
759 chandransh 2274 
    """
3064 chandransh 2275 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2276 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2277 
    used for all other orders as well.
2278 
    Throws an exception if no such order exists.
3431 rajveer 2279 
 
759 chandransh 2280 
    Parameters:
3064 chandransh 2281 
     - orderId
759 chandransh 2282 
    """
3064 chandransh 2283 
    self.send_verifyOrder(orderId)
2284 
    return self.recv_verifyOrder()
759 chandransh 2285 
 
3064 chandransh 2286 
  def send_verifyOrder(self, orderId):
2287 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2288 
    args = verifyOrder_args()
2289 
    args.orderId = orderId
759 chandransh 2290 
    args.write(self._oprot)
2291 
    self._oprot.writeMessageEnd()
2292 
    self._oprot.trans.flush()
2293 
 
3064 chandransh 2294 
  def recv_verifyOrder(self, ):
759 chandransh 2295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2296 
    if mtype == TMessageType.EXCEPTION:
2297 
      x = TApplicationException()
2298 
      x.read(self._iprot)
2299 
      self._iprot.readMessageEnd()
2300 
      raise x
3064 chandransh 2301 
    result = verifyOrder_result()
759 chandransh 2302 
    result.read(self._iprot)
2303 
    self._iprot.readMessageEnd()
3431 rajveer 2304 
    if result.success is not None:
759 chandransh 2305 
      return result.success
3431 rajveer 2306 
    if result.ex is not None:
759 chandransh 2307 
      raise result.ex
3064 chandransh 2308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2309 
 
3064 chandransh 2310 
  def acceptOrder(self, orderId):
1113 chandransh 2311 
    """
3064 chandransh 2312 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2313 
    given order is not a COD order, it also captures the payment if the same has
2314 
    not been captured.
2315 
    Throws an exception if no such order exists.
3431 rajveer 2316 
 
1113 chandransh 2317 
    Parameters:
3064 chandransh 2318 
     - orderId
1113 chandransh 2319 
    """
3064 chandransh 2320 
    self.send_acceptOrder(orderId)
2321 
    return self.recv_acceptOrder()
1113 chandransh 2322 
 
3064 chandransh 2323 
  def send_acceptOrder(self, orderId):
2324 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2325 
    args = acceptOrder_args()
2326 
    args.orderId = orderId
1113 chandransh 2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
3064 chandransh 2331 
  def recv_acceptOrder(self, ):
1113 chandransh 2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
3064 chandransh 2338 
    result = acceptOrder_result()
1113 chandransh 2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
3431 rajveer 2341 
    if result.success is not None:
1113 chandransh 2342 
      return result.success
3431 rajveer 2343 
    if result.ex is not None:
1113 chandransh 2344 
      raise result.ex
3064 chandransh 2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2346 
 
5110 mandeep.dh 2347 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2348 
    """
3064 chandransh 2349 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2350 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2351 
    the IMEI no. if a -1 is supplied.
2352 
    Also, it generates an invoice number for the order, marks the order as
2353 
    BILLED and sets the billing timestamp.
2354 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2355 
 
1135 chandransh 2356 
    Parameters:
3064 chandransh 2357 
     - orderId
2358 
     - invoice_number
4658 mandeep.dh 2359 
     - serialNumber
4283 anupam.sin 2360 
     - itemNumber
3064 chandransh 2361 
     - billed_by
4264 rajveer 2362 
     - jacketNumber
4283 anupam.sin 2363 
     - billingType
5110 mandeep.dh 2364 
     - fulfilmentWarehouseId
4763 rajveer 2365 
     - authorize
1135 chandransh 2366 
    """
5110 mandeep.dh 2367 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2368 
    return self.recv_addBillingDetails()
1135 chandransh 2369 
 
5110 mandeep.dh 2370 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2371 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2372 
    args = addBillingDetails_args()
2373 
    args.orderId = orderId
2374 
    args.invoice_number = invoice_number
4658 mandeep.dh 2375 
    args.serialNumber = serialNumber
4283 anupam.sin 2376 
    args.itemNumber = itemNumber
3064 chandransh 2377 
    args.billed_by = billed_by
4264 rajveer 2378 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2379 
    args.billingType = billingType
5110 mandeep.dh 2380 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2381 
    args.authorize = authorize
1135 chandransh 2382 
    args.write(self._oprot)
2383 
    self._oprot.writeMessageEnd()
2384 
    self._oprot.trans.flush()
2385 
 
3064 chandransh 2386 
  def recv_addBillingDetails(self, ):
1135 chandransh 2387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2388 
    if mtype == TMessageType.EXCEPTION:
2389 
      x = TApplicationException()
2390 
      x.read(self._iprot)
2391 
      self._iprot.readMessageEnd()
2392 
      raise x
3064 chandransh 2393 
    result = addBillingDetails_result()
1135 chandransh 2394 
    result.read(self._iprot)
2395 
    self._iprot.readMessageEnd()
3431 rajveer 2396 
    if result.success is not None:
3064 chandransh 2397 
      return result.success
3431 rajveer 2398 
    if result.ex is not None:
1135 chandransh 2399 
      raise result.ex
3064 chandransh 2400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2401 
 
4763 rajveer 2402 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2403 
    """
2404 
    Add the invoice number to the order.
2405 
 
2406 
    Parameters:
2407 
     - orderId
2408 
     - invoiceNumber
4763 rajveer 2409 
     - color
4579 rajveer 2410 
    """
4763 rajveer 2411 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2412 
    self.recv_addInvoiceNumber()
2413 
 
4763 rajveer 2414 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2415 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2416 
    args = addInvoiceNumber_args()
2417 
    args.orderId = orderId
2418 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2419 
    args.color = color
4579 rajveer 2420 
    args.write(self._oprot)
2421 
    self._oprot.writeMessageEnd()
2422 
    self._oprot.trans.flush()
2423 
 
2424 
  def recv_addInvoiceNumber(self, ):
2425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2426 
    if mtype == TMessageType.EXCEPTION:
2427 
      x = TApplicationException()
2428 
      x.read(self._iprot)
2429 
      self._iprot.readMessageEnd()
2430 
      raise x
2431 
    result = addInvoiceNumber_result()
2432 
    result.read(self._iprot)
2433 
    self._iprot.readMessageEnd()
2434 
    if result.ex is not None:
2435 
      raise result.ex
2436 
    return
2437 
 
4910 phani.kuma 2438 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2439 
    """
3064 chandransh 2440 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2441 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2442 
 
1408 ankur.sing 2443 
    Parameters:
3064 chandransh 2444 
     - warehouseId
1408 ankur.sing 2445 
     - providerId
3064 chandransh 2446 
     - cod
4910 phani.kuma 2447 
     - orderIds
1408 ankur.sing 2448 
    """
4910 phani.kuma 2449 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2450 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2451 
 
4910 phani.kuma 2452 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2453 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2454 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2455 
    args.warehouseId = warehouseId
1408 ankur.sing 2456 
    args.providerId = providerId
3064 chandransh 2457 
    args.cod = cod
4910 phani.kuma 2458 
    args.orderIds = orderIds
1408 ankur.sing 2459 
    args.write(self._oprot)
2460 
    self._oprot.writeMessageEnd()
2461 
    self._oprot.trans.flush()
2462 
 
4910 phani.kuma 2463 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2465 
    if mtype == TMessageType.EXCEPTION:
2466 
      x = TApplicationException()
2467 
      x.read(self._iprot)
2468 
      self._iprot.readMessageEnd()
2469 
      raise x
4910 phani.kuma 2470 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2471 
    result.read(self._iprot)
2472 
    self._iprot.readMessageEnd()
3431 rajveer 2473 
    if result.success is not None:
1408 ankur.sing 2474 
      return result.success
3431 rajveer 2475 
    if result.ex is not None:
3064 chandransh 2476 
      raise result.ex
4910 phani.kuma 2477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2478 
 
4910 phani.kuma 2479 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2480 
    """
4910 phani.kuma 2481 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2482 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2483 
 
2484 
    Parameters:
2485 
     - providerId
4910 phani.kuma 2486 
     - pickupDetails
4410 rajveer 2487 
    """
4910 phani.kuma 2488 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2489 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2490 
 
4910 phani.kuma 2491 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2492 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2493 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2494 
    args.providerId = providerId
4910 phani.kuma 2495 
    args.pickupDetails = pickupDetails
4410 rajveer 2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
4910 phani.kuma 2500 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
4910 phani.kuma 2507 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
2510 
    if result.ex is not None:
2511 
      raise result.ex
4910 phani.kuma 2512 
    return
4410 rajveer 2513 
 
4910 phani.kuma 2514 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2515 
    """
3064 chandransh 2516 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2517 
 
94 ashish 2518 
    Parameters:
3064 chandransh 2519 
     - providerId
304 ashish 2520 
    """
4910 phani.kuma 2521 
    self.send_getOrdersNotPickedUp(providerId)
2522 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2523 
 
4910 phani.kuma 2524 
  def send_getOrdersNotPickedUp(self, providerId):
2525 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2526 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2527 
    args.providerId = providerId
304 ashish 2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
4910 phani.kuma 2532 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
4910 phani.kuma 2539 
    result = getOrdersNotPickedUp_result()
304 ashish 2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
3431 rajveer 2542 
    if result.success is not None:
304 ashish 2543 
      return result.success
4910 phani.kuma 2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2545 
 
3064 chandransh 2546 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2547 
    """
3064 chandransh 2548 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2549 
    the name of the receiver.
2550 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2551 
 
304 ashish 2552 
    Parameters:
3064 chandransh 2553 
     - providerId
2554 
     - deliveredOrders
304 ashish 2555 
    """
3064 chandransh 2556 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2557 
    self.recv_markOrdersAsDelivered()
304 ashish 2558 
 
3064 chandransh 2559 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2560 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2561 
    args = markOrdersAsDelivered_args()
2562 
    args.providerId = providerId
2563 
    args.deliveredOrders = deliveredOrders
304 ashish 2564 
    args.write(self._oprot)
2565 
    self._oprot.writeMessageEnd()
2566 
    self._oprot.trans.flush()
2567 
 
3064 chandransh 2568 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2570 
    if mtype == TMessageType.EXCEPTION:
2571 
      x = TApplicationException()
2572 
      x.read(self._iprot)
2573 
      self._iprot.readMessageEnd()
2574 
      raise x
3064 chandransh 2575 
    result = markOrdersAsDelivered_result()
304 ashish 2576 
    result.read(self._iprot)
2577 
    self._iprot.readMessageEnd()
3431 rajveer 2578 
    if result.ex is not None:
3064 chandransh 2579 
      raise result.ex
304 ashish 2580 
    return
2581 
 
4910 phani.kuma 2582 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2583 
    """
4910 phani.kuma 2584 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2585 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2586 
 
3064 chandransh 2587 
    Parameters:
2588 
     - providerId
2589 
     - returnedOrders
1596 ankur.sing 2590 
    """
4910 phani.kuma 2591 
    self.send_markAsRTOrders(providerId, returnedOrders)
2592 
    self.recv_markAsRTOrders()
304 ashish 2593 
 
4910 phani.kuma 2594 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2595 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2596 
    args = markAsRTOrders_args()
3064 chandransh 2597 
    args.providerId = providerId
2598 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
4910 phani.kuma 2603 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
4910 phani.kuma 2610 
    result = markAsRTOrders_result()
1596 ankur.sing 2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
3431 rajveer 2613 
    if result.ex is not None:
3064 chandransh 2614 
      raise result.ex
2615 
    return
1596 ankur.sing 2616 
 
4910 phani.kuma 2617 
  def getRTOrders(self, providerId):
2618 
    """
2619 
    Returns a list of orders that were returned by courier.
2620 
 
2621 
    Parameters:
2622 
     - providerId
2623 
    """
2624 
    self.send_getRTOrders(providerId)
2625 
    return self.recv_getRTOrders()
2626 
 
2627 
  def send_getRTOrders(self, providerId):
2628 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2629 
    args = getRTOrders_args()
2630 
    args.providerId = providerId
2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
2635 
  def recv_getRTOrders(self, ):
2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
2642 
    result = getRTOrders_result()
2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    if result.success is not None:
2646 
      return result.success
2647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2648 
 
3064 chandransh 2649 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2650 
    """
3064 chandransh 2651 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2652 
 
3064 chandransh 2653 
    Parameters:
2654 
     - providerId
2655 
     - undeliveredOrders
1627 ankur.sing 2656 
    """
3064 chandransh 2657 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2658 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2659 
 
3064 chandransh 2660 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2661 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2662 
    args = updateNonDeliveryReason_args()
2663 
    args.providerId = providerId
2664 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
3064 chandransh 2669 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
3064 chandransh 2676 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
4910 phani.kuma 2679 
    if result.ex is not None:
2680 
      raise result.ex
2681 
    return
2682 
 
2683 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2684 
    """
2685 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2686 
 
2687 
    Parameters:
2688 
     - providerId
2689 
    """
2690 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2691 
    return self.recv_getNonDeliveredOrdersbyCourier()
2692 
 
2693 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2694 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2695 
    args = getNonDeliveredOrdersbyCourier_args()
2696 
    args.providerId = providerId
2697 
    args.write(self._oprot)
2698 
    self._oprot.writeMessageEnd()
2699 
    self._oprot.trans.flush()
2700 
 
2701 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2703 
    if mtype == TMessageType.EXCEPTION:
2704 
      x = TApplicationException()
2705 
      x.read(self._iprot)
2706 
      self._iprot.readMessageEnd()
2707 
      raise x
2708 
    result = getNonDeliveredOrdersbyCourier_result()
2709 
    result.read(self._iprot)
2710 
    self._iprot.readMessageEnd()
4581 phani.kuma 2711 
    if result.success is not None:
2712 
      return result.success
4910 phani.kuma 2713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2714 
 
2715 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2716 
    """
2717 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2718 
 
2719 
    Parameters:
2720 
     - providerId
2721 
     - local_connected_orders
2722 
    """
2723 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2724 
    self.recv_markOrdersAsLocalConnected()
2725 
 
2726 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2727 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2728 
    args = markOrdersAsLocalConnected_args()
2729 
    args.providerId = providerId
2730 
    args.local_connected_orders = local_connected_orders
2731 
    args.write(self._oprot)
2732 
    self._oprot.writeMessageEnd()
2733 
    self._oprot.trans.flush()
2734 
 
2735 
  def recv_markOrdersAsLocalConnected(self, ):
2736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2737 
    if mtype == TMessageType.EXCEPTION:
2738 
      x = TApplicationException()
2739 
      x.read(self._iprot)
2740 
      self._iprot.readMessageEnd()
2741 
      raise x
2742 
    result = markOrdersAsLocalConnected_result()
2743 
    result.read(self._iprot)
2744 
    self._iprot.readMessageEnd()
3431 rajveer 2745 
    if result.ex is not None:
3064 chandransh 2746 
      raise result.ex
4910 phani.kuma 2747 
    return
1627 ankur.sing 2748 
 
4910 phani.kuma 2749 
  def getOrdersNotLocalConnected(self, providerId):
2750 
    """
2751 
    Returns a list of orders that were picked up or shipped but pending local connection.
2752 
 
2753 
    Parameters:
2754 
     - providerId
2755 
    """
2756 
    self.send_getOrdersNotLocalConnected(providerId)
2757 
    return self.recv_getOrdersNotLocalConnected()
2758 
 
2759 
  def send_getOrdersNotLocalConnected(self, providerId):
2760 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2761 
    args = getOrdersNotLocalConnected_args()
2762 
    args.providerId = providerId
2763 
    args.write(self._oprot)
2764 
    self._oprot.writeMessageEnd()
2765 
    self._oprot.trans.flush()
2766 
 
2767 
  def recv_getOrdersNotLocalConnected(self, ):
2768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2769 
    if mtype == TMessageType.EXCEPTION:
2770 
      x = TApplicationException()
2771 
      x.read(self._iprot)
2772 
      self._iprot.readMessageEnd()
2773 
      raise x
2774 
    result = getOrdersNotLocalConnected_result()
2775 
    result.read(self._iprot)
2776 
    self._iprot.readMessageEnd()
2777 
    if result.success is not None:
2778 
      return result.success
2779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2780 
 
2781 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2782 
    """
2783 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2784 
 
2785 
    Parameters:
2786 
     - providerId
2787 
     - destination_city_reached_orders
2788 
    """
2789 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2790 
    self.recv_markOrdersAsDestinationCityReached()
2791 
 
2792 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2793 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2794 
    args = markOrdersAsDestinationCityReached_args()
2795 
    args.providerId = providerId
2796 
    args.destination_city_reached_orders = destination_city_reached_orders
2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
2801 
  def recv_markOrdersAsDestinationCityReached(self, ):
2802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2803 
    if mtype == TMessageType.EXCEPTION:
2804 
      x = TApplicationException()
2805 
      x.read(self._iprot)
2806 
      self._iprot.readMessageEnd()
2807 
      raise x
2808 
    result = markOrdersAsDestinationCityReached_result()
2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
2811 
    if result.ex is not None:
2812 
      raise result.ex
2813 
    return
2814 
 
2815 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2816 
    """
2817 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2818 
 
2819 
    Parameters:
2820 
     - providerId
2821 
     - first_atdl_orders
2822 
    """
2823 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2824 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2825 
 
2826 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2827 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2828 
    args = markOrdersAsFirstDeliveryAttempted_args()
2829 
    args.providerId = providerId
2830 
    args.first_atdl_orders = first_atdl_orders
2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2835 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2842 
    result = markOrdersAsFirstDeliveryAttempted_result()
2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
2845 
    if result.ex is not None:
2846 
      raise result.ex
2847 
    return
2848 
 
3064 chandransh 2849 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2850 
    """
3064 chandransh 2851 
    Returns the list of orders whose delivery time has passed but have not been
2852 
    delivered yet for the given provider and warehouse. To get a complete list of
2853 
    undelivered orders, pass them as -1.
2854 
    Returns an empty list if no such orders exist.
3431 rajveer 2855 
 
1886 ankur.sing 2856 
    Parameters:
3064 chandransh 2857 
     - providerId
2858 
     - warehouseId
1886 ankur.sing 2859 
    """
3064 chandransh 2860 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2861 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2862 
 
3064 chandransh 2863 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2864 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2865 
    args = getUndeliveredOrders_args()
2866 
    args.providerId = providerId
2867 
    args.warehouseId = warehouseId
1886 ankur.sing 2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
3064 chandransh 2872 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2874 
    if mtype == TMessageType.EXCEPTION:
2875 
      x = TApplicationException()
2876 
      x.read(self._iprot)
2877 
      self._iprot.readMessageEnd()
2878 
      raise x
3064 chandransh 2879 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
3431 rajveer 2882 
    if result.success is not None:
1886 ankur.sing 2883 
      return result.success
3064 chandransh 2884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2885 
 
4783 phani.kuma 2886 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2887 
    """
2888 
    Returns the list of orders whose expected delivery date has passed but have not been
2889 
    delivered yet.
2890 
    Returns an empty list if no such orders exist.
2891 
    """
2892 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2893 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2894 
 
2895 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2896 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2897 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2898 
    args.write(self._oprot)
2899 
    self._oprot.writeMessageEnd()
2900 
    self._oprot.trans.flush()
2901 
 
2902 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2904 
    if mtype == TMessageType.EXCEPTION:
2905 
      x = TApplicationException()
2906 
      x.read(self._iprot)
2907 
      self._iprot.readMessageEnd()
2908 
      raise x
2909 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2910 
    result.read(self._iprot)
2911 
    self._iprot.readMessageEnd()
2912 
    if result.success is not None:
2913 
      return result.success
2914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2915 
 
2536 chandransh 2916 
  def toggleDOAFlag(self, orderId):
2917 
    """
2918 
    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.
2919 
    Returns the final flag status.
2920 
    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 2921 
 
2536 chandransh 2922 
    Parameters:
2923 
     - orderId
2924 
    """
2925 
    self.send_toggleDOAFlag(orderId)
2926 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2927 
 
2536 chandransh 2928 
  def send_toggleDOAFlag(self, orderId):
2929 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2930 
    args = toggleDOAFlag_args()
2931 
    args.orderId = orderId
2932 
    args.write(self._oprot)
2933 
    self._oprot.writeMessageEnd()
2934 
    self._oprot.trans.flush()
2935 
 
2936 
  def recv_toggleDOAFlag(self, ):
2937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2938 
    if mtype == TMessageType.EXCEPTION:
2939 
      x = TApplicationException()
2940 
      x.read(self._iprot)
2941 
      self._iprot.readMessageEnd()
2942 
      raise x
2943 
    result = toggleDOAFlag_result()
2944 
    result.read(self._iprot)
2945 
    self._iprot.readMessageEnd()
3431 rajveer 2946 
    if result.success is not None:
2536 chandransh 2947 
      return result.success
3431 rajveer 2948 
    if result.ex is not None:
2536 chandransh 2949 
      raise result.ex
2950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2951 
 
4712 rajveer 2952 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2953 
    """
2954 
    Parameters:
2955 
     - orderId
2956 
     - deliveryTimestamp
2957 
     - receiver
2958 
    """
2959 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2960 
    self.recv_markOrderAsDelivered()
2961 
 
2962 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2963 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2964 
    args = markOrderAsDelivered_args()
2965 
    args.orderId = orderId
2966 
    args.deliveryTimestamp = deliveryTimestamp
2967 
    args.receiver = receiver
2968 
    args.write(self._oprot)
2969 
    self._oprot.writeMessageEnd()
2970 
    self._oprot.trans.flush()
2971 
 
2972 
  def recv_markOrderAsDelivered(self, ):
2973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2974 
    if mtype == TMessageType.EXCEPTION:
2975 
      x = TApplicationException()
2976 
      x.read(self._iprot)
2977 
      self._iprot.readMessageEnd()
2978 
      raise x
2979 
    result = markOrderAsDelivered_result()
2980 
    result.read(self._iprot)
2981 
    self._iprot.readMessageEnd()
2982 
    if result.ex is not None:
2983 
      raise result.ex
2984 
    return
2985 
 
4454 rajveer 2986 
  def markOrderDoaRequestReceived(self, orderId):
2987 
    """
2988 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2989 
 
2990 
    Parameters:
2991 
     - orderId
2992 
    """
2993 
    self.send_markOrderDoaRequestReceived(orderId)
2994 
    return self.recv_markOrderDoaRequestReceived()
2995 
 
2996 
  def send_markOrderDoaRequestReceived(self, orderId):
2997 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2998 
    args = markOrderDoaRequestReceived_args()
2999 
    args.orderId = orderId
3000 
    args.write(self._oprot)
3001 
    self._oprot.writeMessageEnd()
3002 
    self._oprot.trans.flush()
3003 
 
3004 
  def recv_markOrderDoaRequestReceived(self, ):
3005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3006 
    if mtype == TMessageType.EXCEPTION:
3007 
      x = TApplicationException()
3008 
      x.read(self._iprot)
3009 
      self._iprot.readMessageEnd()
3010 
      raise x
3011 
    result = markOrderDoaRequestReceived_result()
3012 
    result.read(self._iprot)
3013 
    self._iprot.readMessageEnd()
3014 
    if result.success is not None:
3015 
      return result.success
3016 
    if result.ex is not None:
3017 
      raise result.ex
3018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3019 
 
3020 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3021 
    """
3022 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3023 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3024 
 
3025 
    Parameters:
3026 
     - orderId
3027 
     - isAuthorized
3028 
    """
3029 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3030 
    return self.recv_markOrderDoaRequestAuthorized()
3031 
 
3032 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3033 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3034 
    args = markOrderDoaRequestAuthorized_args()
3035 
    args.orderId = orderId
3036 
    args.isAuthorized = isAuthorized
3037 
    args.write(self._oprot)
3038 
    self._oprot.writeMessageEnd()
3039 
    self._oprot.trans.flush()
3040 
 
3041 
  def recv_markOrderDoaRequestAuthorized(self, ):
3042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3043 
    if mtype == TMessageType.EXCEPTION:
3044 
      x = TApplicationException()
3045 
      x.read(self._iprot)
3046 
      self._iprot.readMessageEnd()
3047 
      raise x
3048 
    result = markOrderDoaRequestAuthorized_result()
3049 
    result.read(self._iprot)
3050 
    self._iprot.readMessageEnd()
3051 
    if result.success is not None:
3052 
      return result.success
3053 
    if result.ex is not None:
3054 
      raise result.ex
3055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3056 
 
4488 rajveer 3057 
  def markOrderReturnRequestReceived(self, orderId):
3058 
    """
3059 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3060 
 
3061 
    Parameters:
3062 
     - orderId
3063 
    """
3064 
    self.send_markOrderReturnRequestReceived(orderId)
3065 
    return self.recv_markOrderReturnRequestReceived()
3066 
 
3067 
  def send_markOrderReturnRequestReceived(self, orderId):
3068 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3069 
    args = markOrderReturnRequestReceived_args()
3070 
    args.orderId = orderId
3071 
    args.write(self._oprot)
3072 
    self._oprot.writeMessageEnd()
3073 
    self._oprot.trans.flush()
3074 
 
3075 
  def recv_markOrderReturnRequestReceived(self, ):
3076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3077 
    if mtype == TMessageType.EXCEPTION:
3078 
      x = TApplicationException()
3079 
      x.read(self._iprot)
3080 
      self._iprot.readMessageEnd()
3081 
      raise x
3082 
    result = markOrderReturnRequestReceived_result()
3083 
    result.read(self._iprot)
3084 
    self._iprot.readMessageEnd()
3085 
    if result.success is not None:
3086 
      return result.success
3087 
    if result.ex is not None:
3088 
      raise result.ex
3089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3090 
 
3091 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3092 
    """
3093 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3094 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3095 
 
3096 
    Parameters:
3097 
     - orderId
3098 
     - isAuthorized
3099 
    """
3100 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3101 
    return self.recv_markOrderReturnRequestAuthorized()
3102 
 
3103 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3104 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3105 
    args = markOrderReturnRequestAuthorized_args()
3106 
    args.orderId = orderId
3107 
    args.isAuthorized = isAuthorized
3108 
    args.write(self._oprot)
3109 
    self._oprot.writeMessageEnd()
3110 
    self._oprot.trans.flush()
3111 
 
3112 
  def recv_markOrderReturnRequestAuthorized(self, ):
3113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3114 
    if mtype == TMessageType.EXCEPTION:
3115 
      x = TApplicationException()
3116 
      x.read(self._iprot)
3117 
      self._iprot.readMessageEnd()
3118 
      raise x
3119 
    result = markOrderReturnRequestAuthorized_result()
3120 
    result.read(self._iprot)
3121 
    self._iprot.readMessageEnd()
3122 
    if result.success is not None:
3123 
      return result.success
3124 
    if result.ex is not None:
3125 
      raise result.ex
3126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3127 
 
4579 rajveer 3128 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3129 
    """
3130 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3131 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3132 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3133 
    For any other status, it returns false.
3134 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3135 
 
2536 chandransh 3136 
    Parameters:
3137 
     - orderId
4579 rajveer 3138 
     - providerId
2536 chandransh 3139 
    """
4579 rajveer 3140 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3141 
    return self.recv_requestPickupNumber()
3142 
 
4579 rajveer 3143 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3144 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3145 
    args = requestPickupNumber_args()
3146 
    args.orderId = orderId
4579 rajveer 3147 
    args.providerId = providerId
2536 chandransh 3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
3152 
  def recv_requestPickupNumber(self, ):
3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
3159 
    result = requestPickupNumber_result()
3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
3431 rajveer 3162 
    if result.success is not None:
2536 chandransh 3163 
      return result.success
3431 rajveer 3164 
    if result.ex is not None:
2536 chandransh 3165 
      raise result.ex
3166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3167 
 
4602 rajveer 3168 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3169 
    """
4452 rajveer 3170 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3171 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3172 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3173 
    	3. Returns true
2591 chandransh 3174 
    If the order is in any other status, it returns false.
2536 chandransh 3175 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3176 
 
2536 chandransh 3177 
    Parameters:
3178 
     - orderId
3179 
     - pickupNumber
4602 rajveer 3180 
     - providerId
2536 chandransh 3181 
    """
4602 rajveer 3182 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3183 
    return self.recv_authorizePickup()
3184 
 
4602 rajveer 3185 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3186 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3187 
    args = authorizePickup_args()
3188 
    args.orderId = orderId
3189 
    args.pickupNumber = pickupNumber
4602 rajveer 3190 
    args.providerId = providerId
2536 chandransh 3191 
    args.write(self._oprot)
3192 
    self._oprot.writeMessageEnd()
3193 
    self._oprot.trans.flush()
3194 
 
3195 
  def recv_authorizePickup(self, ):
3196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3197 
    if mtype == TMessageType.EXCEPTION:
3198 
      x = TApplicationException()
3199 
      x.read(self._iprot)
3200 
      self._iprot.readMessageEnd()
3201 
      raise x
3202 
    result = authorizePickup_result()
3203 
    result.read(self._iprot)
3204 
    self._iprot.readMessageEnd()
3431 rajveer 3205 
    if result.success is not None:
2536 chandransh 3206 
      return result.success
3431 rajveer 3207 
    if result.ex is not None:
2536 chandransh 3208 
      raise result.ex
3209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3210 
 
2764 chandransh 3211 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3212 
    """
3213 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3214 
 
2764 chandransh 3215 
    Parameters:
3216 
     - providerId
3217 
     - pickupDetails
3218 
    """
3219 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3220 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3221 
 
3222 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3223 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3224 
    args = markDoasAsPickedUp_args()
3225 
    args.providerId = providerId
3226 
    args.pickupDetails = pickupDetails
3227 
    args.write(self._oprot)
3228 
    self._oprot.writeMessageEnd()
3229 
    self._oprot.trans.flush()
3230 
 
3231 
  def recv_markDoasAsPickedUp(self, ):
3232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3233 
    if mtype == TMessageType.EXCEPTION:
3234 
      x = TApplicationException()
3235 
      x.read(self._iprot)
3236 
      self._iprot.readMessageEnd()
3237 
      raise x
3238 
    result = markDoasAsPickedUp_result()
3239 
    result.read(self._iprot)
3240 
    self._iprot.readMessageEnd()
4910 phani.kuma 3241 
    return
3242 
 
3243 
  def getDoasNotPickedUp(self, providerId):
3244 
    """
3245 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3246 
 
3247 
    Parameters:
3248 
     - providerId
3249 
    """
3250 
    self.send_getDoasNotPickedUp(providerId)
3251 
    return self.recv_getDoasNotPickedUp()
3252 
 
3253 
  def send_getDoasNotPickedUp(self, providerId):
3254 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3255 
    args = getDoasNotPickedUp_args()
3256 
    args.providerId = providerId
3257 
    args.write(self._oprot)
3258 
    self._oprot.writeMessageEnd()
3259 
    self._oprot.trans.flush()
3260 
 
3261 
  def recv_getDoasNotPickedUp(self, ):
3262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3263 
    if mtype == TMessageType.EXCEPTION:
3264 
      x = TApplicationException()
3265 
      x.read(self._iprot)
3266 
      self._iprot.readMessageEnd()
3267 
      raise x
3268 
    result = getDoasNotPickedUp_result()
3269 
    result.read(self._iprot)
3270 
    self._iprot.readMessageEnd()
3431 rajveer 3271 
    if result.success is not None:
2764 chandransh 3272 
      return result.success
4910 phani.kuma 3273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3274 
 
4741 phani.kuma 3275 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3276 
    """
3277 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3278 
 
3279 
    Parameters:
3280 
     - providerId
3281 
     - pickupDetails
3282 
    """
3283 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3284 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3285 
 
3286 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3287 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3288 
    args = markReturnOrdersAsPickedUp_args()
3289 
    args.providerId = providerId
3290 
    args.pickupDetails = pickupDetails
3291 
    args.write(self._oprot)
3292 
    self._oprot.writeMessageEnd()
3293 
    self._oprot.trans.flush()
3294 
 
3295 
  def recv_markReturnOrdersAsPickedUp(self, ):
3296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3297 
    if mtype == TMessageType.EXCEPTION:
3298 
      x = TApplicationException()
3299 
      x.read(self._iprot)
3300 
      self._iprot.readMessageEnd()
3301 
      raise x
3302 
    result = markReturnOrdersAsPickedUp_result()
3303 
    result.read(self._iprot)
3304 
    self._iprot.readMessageEnd()
4910 phani.kuma 3305 
    return
3306 
 
3307 
  def getReturnOrdersNotPickedUp(self, providerId):
3308 
    """
3309 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3310 
 
3311 
    Parameters:
3312 
     - providerId
3313 
    """
3314 
    self.send_getReturnOrdersNotPickedUp(providerId)
3315 
    return self.recv_getReturnOrdersNotPickedUp()
3316 
 
3317 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3318 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3319 
    args = getReturnOrdersNotPickedUp_args()
3320 
    args.providerId = providerId
3321 
    args.write(self._oprot)
3322 
    self._oprot.writeMessageEnd()
3323 
    self._oprot.trans.flush()
3324 
 
3325 
  def recv_getReturnOrdersNotPickedUp(self, ):
3326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3327 
    if mtype == TMessageType.EXCEPTION:
3328 
      x = TApplicationException()
3329 
      x.read(self._iprot)
3330 
      self._iprot.readMessageEnd()
3331 
      raise x
3332 
    result = getReturnOrdersNotPickedUp_result()
3333 
    result.read(self._iprot)
3334 
    self._iprot.readMessageEnd()
4741 phani.kuma 3335 
    if result.success is not None:
3336 
      return result.success
4910 phani.kuma 3337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3338 
 
4479 rajveer 3339 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3340 
    """
4452 rajveer 3341 
    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 3342 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3343 
    If the order is in any other state, it returns false.
3344 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3345 
 
2591 chandransh 3346 
    Parameters:
3347 
     - orderId
4479 rajveer 3348 
     - receiveCondition
2591 chandransh 3349 
    """
4479 rajveer 3350 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3351 
    return self.recv_receiveReturn()
2536 chandransh 3352 
 
4479 rajveer 3353 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3354 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3355 
    args = receiveReturn_args()
2591 chandransh 3356 
    args.orderId = orderId
4479 rajveer 3357 
    args.receiveCondition = receiveCondition
2591 chandransh 3358 
    args.write(self._oprot)
3359 
    self._oprot.writeMessageEnd()
3360 
    self._oprot.trans.flush()
3361 
 
2616 chandransh 3362 
  def recv_receiveReturn(self, ):
2591 chandransh 3363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3364 
    if mtype == TMessageType.EXCEPTION:
3365 
      x = TApplicationException()
3366 
      x.read(self._iprot)
3367 
      self._iprot.readMessageEnd()
3368 
      raise x
2616 chandransh 3369 
    result = receiveReturn_result()
2591 chandransh 3370 
    result.read(self._iprot)
3371 
    self._iprot.readMessageEnd()
3431 rajveer 3372 
    if result.success is not None:
2591 chandransh 3373 
      return result.success
3431 rajveer 3374 
    if result.ex is not None:
2591 chandransh 3375 
      raise result.ex
2616 chandransh 3376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3377 
 
3378 
  def validateDoa(self, orderId, isValid):
3379 
    """
4452 rajveer 3380 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3381 
    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 3382 
    If the order is in any other state, it returns false.
3383 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3384 
 
2591 chandransh 3385 
    Parameters:
3386 
     - orderId
3387 
     - isValid
3388 
    """
3389 
    self.send_validateDoa(orderId, isValid)
3390 
    return self.recv_validateDoa()
3391 
 
3392 
  def send_validateDoa(self, orderId, isValid):
3393 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3394 
    args = validateDoa_args()
3395 
    args.orderId = orderId
3396 
    args.isValid = isValid
3397 
    args.write(self._oprot)
3398 
    self._oprot.writeMessageEnd()
3399 
    self._oprot.trans.flush()
3400 
 
3401 
  def recv_validateDoa(self, ):
3402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3403 
    if mtype == TMessageType.EXCEPTION:
3404 
      x = TApplicationException()
3405 
      x.read(self._iprot)
3406 
      self._iprot.readMessageEnd()
3407 
      raise x
3408 
    result = validateDoa_result()
3409 
    result.read(self._iprot)
3410 
    self._iprot.readMessageEnd()
3431 rajveer 3411 
    if result.success is not None:
2591 chandransh 3412 
      return result.success
3431 rajveer 3413 
    if result.ex is not None:
2591 chandransh 3414 
      raise result.ex
3415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3416 
 
4495 rajveer 3417 
  def validateReturnProduct(self, orderId, isUsable):
3418 
    """
3419 
    Parameters:
3420 
     - orderId
3421 
     - isUsable
3422 
    """
3423 
    self.send_validateReturnProduct(orderId, isUsable)
3424 
    return self.recv_validateReturnProduct()
3425 
 
3426 
  def send_validateReturnProduct(self, orderId, isUsable):
3427 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3428 
    args = validateReturnProduct_args()
3429 
    args.orderId = orderId
3430 
    args.isUsable = isUsable
3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_validateReturnProduct(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = validateReturnProduct_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    if result.success is not None:
3446 
      return result.success
3447 
    if result.ex is not None:
3448 
      raise result.ex
3449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3450 
 
2616 chandransh 3451 
  def reshipOrder(self, orderId):
3452 
    """
4484 rajveer 3453 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3454 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3455 
    	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 3456 
 
3457 
    If the order is in DOA_CERT_VALID state, it does the following:
3458 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3459 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3460 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3461 
 
2616 chandransh 3462 
    Returns the id of the newly created order.
3431 rajveer 3463 
 
2616 chandransh 3464 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3465 
 
2616 chandransh 3466 
    Parameters:
3467 
     - orderId
3468 
    """
3469 
    self.send_reshipOrder(orderId)
3470 
    return self.recv_reshipOrder()
2591 chandransh 3471 
 
2616 chandransh 3472 
  def send_reshipOrder(self, orderId):
3473 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3474 
    args = reshipOrder_args()
3475 
    args.orderId = orderId
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_reshipOrder(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = reshipOrder_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
3431 rajveer 3490 
    if result.success is not None:
2616 chandransh 3491 
      return result.success
3431 rajveer 3492 
    if result.ex is not None:
2616 chandransh 3493 
      raise result.ex
3494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3495 
 
3226 chandransh 3496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3497 
    """
4484 rajveer 3498 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3499 
    	1. Creates a refund request for batch processing.
3500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3501 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3502 
 
2616 chandransh 3503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3504 
    	1. Creates a refund request for batch processing.
3226 chandransh 3505 
    	2. Cancels the reservation of the item in the warehouse.
3506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3507 
 
3226 chandransh 3508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3509 
    	1. Cancels the reservation of the item in the warehouse.
3510 
    	2. Marks the current order as CANCELED.
3511 
 
3512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3513 
 
2616 chandransh 3514 
    Returns True if it is successful, False otherwise.
3431 rajveer 3515 
 
2616 chandransh 3516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3517 
 
2616 chandransh 3518 
    Parameters:
3519 
     - orderId
3226 chandransh 3520 
     - refundedBy
3521 
     - reason
2616 chandransh 3522 
    """
3226 chandransh 3523 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3524 
    return self.recv_refundOrder()
3525 
 
3226 chandransh 3526 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3527 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3528 
    args = refundOrder_args()
3529 
    args.orderId = orderId
3226 chandransh 3530 
    args.refundedBy = refundedBy
3531 
    args.reason = reason
2616 chandransh 3532 
    args.write(self._oprot)
3533 
    self._oprot.writeMessageEnd()
3534 
    self._oprot.trans.flush()
3535 
 
3536 
  def recv_refundOrder(self, ):
3537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3538 
    if mtype == TMessageType.EXCEPTION:
3539 
      x = TApplicationException()
3540 
      x.read(self._iprot)
3541 
      self._iprot.readMessageEnd()
3542 
      raise x
3543 
    result = refundOrder_result()
3544 
    result.read(self._iprot)
3545 
    self._iprot.readMessageEnd()
3431 rajveer 3546 
    if result.success is not None:
2616 chandransh 3547 
      return result.success
3431 rajveer 3548 
    if result.ex is not None:
2616 chandransh 3549 
      raise result.ex
3550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3551 
 
2690 chandransh 3552 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3553 
    """
3554 
    Get all return orders created between the from and to dates for the given warehouse.
3555 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3556 
 
2690 chandransh 3557 
    Parameters:
3558 
     - warehouseId
3559 
     - fromDate
3560 
     - toDate
3561 
    """
3562 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3563 
    return self.recv_getReturnOrders()
2616 chandransh 3564 
 
2690 chandransh 3565 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3566 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3567 
    args = getReturnOrders_args()
3568 
    args.warehouseId = warehouseId
3569 
    args.fromDate = fromDate
3570 
    args.toDate = toDate
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_getReturnOrders(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = getReturnOrders_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3431 rajveer 3585 
    if result.success is not None:
2690 chandransh 3586 
      return result.success
3587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3588 
 
2700 chandransh 3589 
  def getReturnOrder(self, id):
3590 
    """
3591 
    Returns the ReturnOrder corresponding to the given id.
3592 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3593 
 
2700 chandransh 3594 
    Parameters:
3595 
     - id
3596 
    """
3597 
    self.send_getReturnOrder(id)
3598 
    return self.recv_getReturnOrder()
3599 
 
3600 
  def send_getReturnOrder(self, id):
3601 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3602 
    args = getReturnOrder_args()
3603 
    args.id = id
3604 
    args.write(self._oprot)
3605 
    self._oprot.writeMessageEnd()
3606 
    self._oprot.trans.flush()
3607 
 
3608 
  def recv_getReturnOrder(self, ):
3609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3610 
    if mtype == TMessageType.EXCEPTION:
3611 
      x = TApplicationException()
3612 
      x.read(self._iprot)
3613 
      self._iprot.readMessageEnd()
3614 
      raise x
3615 
    result = getReturnOrder_result()
3616 
    result.read(self._iprot)
3617 
    self._iprot.readMessageEnd()
3431 rajveer 3618 
    if result.success is not None:
2700 chandransh 3619 
      return result.success
3431 rajveer 3620 
    if result.ex is not None:
2700 chandransh 3621 
      raise result.ex
3622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3623 
 
2690 chandransh 3624 
  def processReturn(self, returnOrderId):
3625 
    """
3626 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3627 
 
2690 chandransh 3628 
    Parameters:
3629 
     - returnOrderId
3630 
    """
3631 
    self.send_processReturn(returnOrderId)
3632 
    self.recv_processReturn()
3633 
 
3634 
  def send_processReturn(self, returnOrderId):
3635 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3636 
    args = processReturn_args()
3637 
    args.returnOrderId = returnOrderId
3638 
    args.write(self._oprot)
3639 
    self._oprot.writeMessageEnd()
3640 
    self._oprot.trans.flush()
3641 
 
3642 
  def recv_processReturn(self, ):
3643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3644 
    if mtype == TMessageType.EXCEPTION:
3645 
      x = TApplicationException()
3646 
      x.read(self._iprot)
3647 
      self._iprot.readMessageEnd()
3648 
      raise x
3649 
    result = processReturn_result()
3650 
    result.read(self._iprot)
3651 
    self._iprot.readMessageEnd()
3431 rajveer 3652 
    if result.ex is not None:
2690 chandransh 3653 
      raise result.ex
3654 
    return
3655 
 
3451 chandransh 3656 
  def updateWeight(self, orderId, weight):
3657 
    """
3658 
    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 3659 
 
3451 chandransh 3660 
    Parameters:
3661 
     - orderId
3662 
     - weight
3663 
    """
3664 
    self.send_updateWeight(orderId, weight)
3665 
    return self.recv_updateWeight()
3666 
 
3667 
  def send_updateWeight(self, orderId, weight):
3668 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3669 
    args = updateWeight_args()
3670 
    args.orderId = orderId
3671 
    args.weight = weight
3672 
    args.write(self._oprot)
3673 
    self._oprot.writeMessageEnd()
3674 
    self._oprot.trans.flush()
3675 
 
3676 
  def recv_updateWeight(self, ):
3677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3678 
    if mtype == TMessageType.EXCEPTION:
3679 
      x = TApplicationException()
3680 
      x.read(self._iprot)
3681 
      self._iprot.readMessageEnd()
3682 
      raise x
3683 
    result = updateWeight_result()
3684 
    result.read(self._iprot)
3685 
    self._iprot.readMessageEnd()
3686 
    if result.success is not None:
3687 
      return result.success
3688 
    if result.ex is not None:
3689 
      raise result.ex
3690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3691 
 
3469 chandransh 3692 
  def changeItem(self, orderId, itemId):
3693 
    """
3694 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3695 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3696 
 
3469 chandransh 3697 
    Parameters:
3698 
     - orderId
3699 
     - itemId
3700 
    """
3701 
    self.send_changeItem(orderId, itemId)
3702 
    return self.recv_changeItem()
3703 
 
3704 
  def send_changeItem(self, orderId, itemId):
3705 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3706 
    args = changeItem_args()
3707 
    args.orderId = orderId
3708 
    args.itemId = itemId
3709 
    args.write(self._oprot)
3710 
    self._oprot.writeMessageEnd()
3711 
    self._oprot.trans.flush()
3712 
 
3713 
  def recv_changeItem(self, ):
3714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3715 
    if mtype == TMessageType.EXCEPTION:
3716 
      x = TApplicationException()
3717 
      x.read(self._iprot)
3718 
      self._iprot.readMessageEnd()
3719 
      raise x
3720 
    result = changeItem_result()
3721 
    result.read(self._iprot)
3722 
    self._iprot.readMessageEnd()
3723 
    if result.success is not None:
3724 
      return result.success
3725 
    if result.ex is not None:
3726 
      raise result.ex
3727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3728 
 
3729 
  def shiftToWarehouse(self, orderId, warehouseId):
3730 
    """
3731 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3732 
 
3733 
    Parameters:
3734 
     - orderId
3735 
     - warehouseId
3736 
    """
3737 
    self.send_shiftToWarehouse(orderId, warehouseId)
3738 
    return self.recv_shiftToWarehouse()
3739 
 
3740 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3741 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3742 
    args = shiftToWarehouse_args()
3743 
    args.orderId = orderId
3744 
    args.warehouseId = warehouseId
3745 
    args.write(self._oprot)
3746 
    self._oprot.writeMessageEnd()
3747 
    self._oprot.trans.flush()
3748 
 
3749 
  def recv_shiftToWarehouse(self, ):
3750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3751 
    if mtype == TMessageType.EXCEPTION:
3752 
      x = TApplicationException()
3753 
      x.read(self._iprot)
3754 
      self._iprot.readMessageEnd()
3755 
      raise x
3756 
    result = shiftToWarehouse_result()
3757 
    result.read(self._iprot)
3758 
    self._iprot.readMessageEnd()
3759 
    if result.success is not None:
3760 
      return result.success
3761 
    if result.ex is not None:
3762 
      raise result.ex
3763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3764 
 
4647 rajveer 3765 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3766 
    """
3767 
    Adds the given delay reason to the given order.
3986 chandransh 3768 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3769 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3770 
 
3553 chandransh 3771 
    Parameters:
3772 
     - orderId
3773 
     - delayReason
3986 chandransh 3774 
     - furtherDelay
4647 rajveer 3775 
     - delayReasonText
3553 chandransh 3776 
    """
4647 rajveer 3777 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3778 
    return self.recv_addDelayReason()
3779 
 
4647 rajveer 3780 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3781 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3782 
    args = addDelayReason_args()
3783 
    args.orderId = orderId
3784 
    args.delayReason = delayReason
3986 chandransh 3785 
    args.furtherDelay = furtherDelay
4647 rajveer 3786 
    args.delayReasonText = delayReasonText
3553 chandransh 3787 
    args.write(self._oprot)
3788 
    self._oprot.writeMessageEnd()
3789 
    self._oprot.trans.flush()
3790 
 
3791 
  def recv_addDelayReason(self, ):
3792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3793 
    if mtype == TMessageType.EXCEPTION:
3794 
      x = TApplicationException()
3795 
      x.read(self._iprot)
3796 
      self._iprot.readMessageEnd()
3797 
      raise x
3798 
    result = addDelayReason_result()
3799 
    result.read(self._iprot)
3800 
    self._iprot.readMessageEnd()
3801 
    if result.success is not None:
3802 
      return result.success
3803 
    if result.ex is not None:
3804 
      raise result.ex
3805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3806 
 
3956 chandransh 3807 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3808 
    """
3809 
    Marks the COD orders with given AWB nos. as having been processed.
3810 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3811 
 
3956 chandransh 3812 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3813 
    1. There is no order corresponding to an AWB number.
3814 
    2. The captured amount for a payment exceeds the total payment.
3815 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3816 
 
3817 
    Parameters:
3818 
     - collectedAmountMap
3819 
     - xferBy
3820 
     - xferTxnId
3821 
     - xferDate
3822 
    """
3823 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3824 
    return self.recv_reconcileCodCollection()
3825 
 
3826 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3827 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3828 
    args = reconcileCodCollection_args()
3829 
    args.collectedAmountMap = collectedAmountMap
3830 
    args.xferBy = xferBy
3831 
    args.xferTxnId = xferTxnId
3832 
    args.xferDate = xferDate
3833 
    args.write(self._oprot)
3834 
    self._oprot.writeMessageEnd()
3835 
    self._oprot.trans.flush()
3836 
 
3837 
  def recv_reconcileCodCollection(self, ):
3838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3839 
    if mtype == TMessageType.EXCEPTION:
3840 
      x = TApplicationException()
3841 
      x.read(self._iprot)
3842 
      self._iprot.readMessageEnd()
3843 
      raise x
3844 
    result = reconcileCodCollection_result()
3845 
    result.read(self._iprot)
3846 
    self._iprot.readMessageEnd()
3847 
    if result.success is not None:
3848 
      return result.success
3849 
    if result.ex is not None:
3850 
      raise result.ex
3851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3852 
 
4008 mandeep.dh 3853 
  def getTransactionsRequiringExtraProcessing(self, category):
3854 
    """
4065 mandeep.dh 3855 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3856 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3857 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3858 
 
4008 mandeep.dh 3859 
    Parameters:
3860 
     - category
3861 
    """
3862 
    self.send_getTransactionsRequiringExtraProcessing(category)
3863 
    return self.recv_getTransactionsRequiringExtraProcessing()
3864 
 
3865 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3866 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3867 
    args = getTransactionsRequiringExtraProcessing_args()
3868 
    args.category = category
3869 
    args.write(self._oprot)
3870 
    self._oprot.writeMessageEnd()
3871 
    self._oprot.trans.flush()
3872 
 
3873 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3875 
    if mtype == TMessageType.EXCEPTION:
3876 
      x = TApplicationException()
3877 
      x.read(self._iprot)
3878 
      self._iprot.readMessageEnd()
3879 
      raise x
3880 
    result = getTransactionsRequiringExtraProcessing_result()
3881 
    result.read(self._iprot)
3882 
    self._iprot.readMessageEnd()
3883 
    if result.success is not None:
3884 
      return result.success
3885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3886 
 
3887 
  def markTransactionAsProcessed(self, transactionId, category):
3888 
    """
3889 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3890 
    It essentially deletes the transaction id record for a particular
3891 
    processing type category (if present) from DB.
3892 
    This is currently used by CRM application.
4008 mandeep.dh 3893 
 
3894 
    Parameters:
3895 
     - transactionId
3896 
     - category
3897 
    """
3898 
    self.send_markTransactionAsProcessed(transactionId, category)
3899 
    self.recv_markTransactionAsProcessed()
3900 
 
3901 
  def send_markTransactionAsProcessed(self, transactionId, category):
3902 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3903 
    args = markTransactionAsProcessed_args()
3904 
    args.transactionId = transactionId
3905 
    args.category = category
3906 
    args.write(self._oprot)
3907 
    self._oprot.writeMessageEnd()
3908 
    self._oprot.trans.flush()
3909 
 
3910 
  def recv_markTransactionAsProcessed(self, ):
3911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3912 
    if mtype == TMessageType.EXCEPTION:
3913 
      x = TApplicationException()
3914 
      x.read(self._iprot)
3915 
      self._iprot.readMessageEnd()
3916 
      raise x
3917 
    result = markTransactionAsProcessed_result()
3918 
    result.read(self._iprot)
3919 
    self._iprot.readMessageEnd()
3920 
    return
3921 
 
4018 chandransh 3922 
  def getItemWiseRiskyOrdersCount(self, ):
3923 
    """
3924 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3925 
    is defined as one whose shipping date is about to expire.
3926 
    """
3927 
    self.send_getItemWiseRiskyOrdersCount()
3928 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3929 
 
4018 chandransh 3930 
  def send_getItemWiseRiskyOrdersCount(self, ):
3931 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3932 
    args = getItemWiseRiskyOrdersCount_args()
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3939 
    if mtype == TMessageType.EXCEPTION:
3940 
      x = TApplicationException()
3941 
      x.read(self._iprot)
3942 
      self._iprot.readMessageEnd()
3943 
      raise x
3944 
    result = getItemWiseRiskyOrdersCount_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3947 
    if result.success is not None:
3948 
      return result.success
3949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3950 
 
4295 varun.gupt 3951 
  def getOrdersForItemIds(self, itemIds):
3952 
    """
3953 
    Returns a list of all orders which have items with given id
3954 
 
3955 
    Parameters:
3956 
     - itemIds
3957 
    """
3958 
    self.send_getOrdersForItemIds(itemIds)
3959 
    return self.recv_getOrdersForItemIds()
3960 
 
3961 
  def send_getOrdersForItemIds(self, itemIds):
3962 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3963 
    args = getOrdersForItemIds_args()
3964 
    args.itemIds = itemIds
3965 
    args.write(self._oprot)
3966 
    self._oprot.writeMessageEnd()
3967 
    self._oprot.trans.flush()
3968 
 
3969 
  def recv_getOrdersForItemIds(self, ):
3970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3971 
    if mtype == TMessageType.EXCEPTION:
3972 
      x = TApplicationException()
3973 
      x.read(self._iprot)
3974 
      self._iprot.readMessageEnd()
3975 
      raise x
3976 
    result = getOrdersForItemIds_result()
3977 
    result.read(self._iprot)
3978 
    self._iprot.readMessageEnd()
3979 
    if result.success is not None:
3980 
      return result.success
3981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3982 
 
4247 rajveer 3983 
  def markOrderCancellationRequestReceived(self, orderId):
3984 
    """
3985 
    Mark order as cancellation request received. If customer sends request of cancellation of
3986 
    a particular order, this method will be called. It will just change status of the order
3987 
    depending on its current status. It also records the previous status, so that we can move
3988 
    back to that status if cancellation request is denied.
4018 chandransh 3989 
 
4247 rajveer 3990 
    Parameters:
3991 
     - orderId
3992 
    """
3993 
    self.send_markOrderCancellationRequestReceived(orderId)
3994 
    self.recv_markOrderCancellationRequestReceived()
3995 
 
3996 
  def send_markOrderCancellationRequestReceived(self, orderId):
3997 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3998 
    args = markOrderCancellationRequestReceived_args()
3999 
    args.orderId = orderId
4000 
    args.write(self._oprot)
4001 
    self._oprot.writeMessageEnd()
4002 
    self._oprot.trans.flush()
4003 
 
4004 
  def recv_markOrderCancellationRequestReceived(self, ):
4005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4006 
    if mtype == TMessageType.EXCEPTION:
4007 
      x = TApplicationException()
4008 
      x.read(self._iprot)
4009 
      self._iprot.readMessageEnd()
4010 
      raise x
4011 
    result = markOrderCancellationRequestReceived_result()
4012 
    result.read(self._iprot)
4013 
    self._iprot.readMessageEnd()
4014 
    if result.ex is not None:
4015 
      raise result.ex
4016 
    return
4017 
 
4018 
  def markOrderCancellationRequestConfirmed(self, orderId):
4019 
    """
4020 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4021 
    cancellation request confirmed. After this OM will be able to cancel the order.
4022 
 
4023 
    Parameters:
4024 
     - orderId
4025 
    """
4026 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4027 
    self.recv_markOrderCancellationRequestConfirmed()
4028 
 
4029 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4030 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4031 
    args = markOrderCancellationRequestConfirmed_args()
4032 
    args.orderId = orderId
4033 
    args.write(self._oprot)
4034 
    self._oprot.writeMessageEnd()
4035 
    self._oprot.trans.flush()
4036 
 
4037 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4039 
    if mtype == TMessageType.EXCEPTION:
4040 
      x = TApplicationException()
4041 
      x.read(self._iprot)
4042 
      self._iprot.readMessageEnd()
4043 
      raise x
4044 
    result = markOrderCancellationRequestConfirmed_result()
4045 
    result.read(self._iprot)
4046 
    self._iprot.readMessageEnd()
4047 
    if result.ex is not None:
4048 
      raise result.ex
4049 
    return
4050 
 
4051 
  def markOrderCancellationRequestDenied(self, orderId):
4052 
    """
4053 
    If we decide to not to cancel order, we will move the order ro previous status.
4054 
 
4055 
    Parameters:
4056 
     - orderId
4057 
    """
4058 
    self.send_markOrderCancellationRequestDenied(orderId)
4059 
    self.recv_markOrderCancellationRequestDenied()
4060 
 
4061 
  def send_markOrderCancellationRequestDenied(self, orderId):
4062 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4063 
    args = markOrderCancellationRequestDenied_args()
4064 
    args.orderId = orderId
4065 
    args.write(self._oprot)
4066 
    self._oprot.writeMessageEnd()
4067 
    self._oprot.trans.flush()
4068 
 
4069 
  def recv_markOrderCancellationRequestDenied(self, ):
4070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4071 
    if mtype == TMessageType.EXCEPTION:
4072 
      x = TApplicationException()
4073 
      x.read(self._iprot)
4074 
      self._iprot.readMessageEnd()
4075 
      raise x
4076 
    result = markOrderCancellationRequestDenied_result()
4077 
    result.read(self._iprot)
4078 
    self._iprot.readMessageEnd()
4079 
    if result.ex is not None:
4080 
      raise result.ex
4081 
    return
4082 
 
4258 rajveer 4083 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4084 
    """
4258 rajveer 4085 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4086 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4087 
 
4088 
    Parameters:
4258 rajveer 4089 
     - transactionId
4247 rajveer 4090 
    """
4258 rajveer 4091 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4092 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4093 
 
4258 rajveer 4094 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4095 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4096 
    args = markTransactionAsPaymentFlagRemoved_args()
4097 
    args.transactionId = transactionId
4247 rajveer 4098 
    args.write(self._oprot)
4099 
    self._oprot.writeMessageEnd()
4100 
    self._oprot.trans.flush()
4101 
 
4258 rajveer 4102 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4104 
    if mtype == TMessageType.EXCEPTION:
4105 
      x = TApplicationException()
4106 
      x.read(self._iprot)
4107 
      self._iprot.readMessageEnd()
4108 
      raise x
4258 rajveer 4109 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4110 
    result.read(self._iprot)
4111 
    self._iprot.readMessageEnd()
4112 
    if result.ex is not None:
4113 
      raise result.ex
4114 
    return
4115 
 
4259 anupam.sin 4116 
  def refundTransaction(self, transactionId, refundedBy, reason):
4117 
    """
4118 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4119 
    need to be cancelled
4247 rajveer 4120 
 
4259 anupam.sin 4121 
    Parameters:
4122 
     - transactionId
4123 
     - refundedBy
4124 
     - reason
4125 
    """
4126 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4127 
    self.recv_refundTransaction()
4128 
 
4129 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4130 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4131 
    args = refundTransaction_args()
4132 
    args.transactionId = transactionId
4133 
    args.refundedBy = refundedBy
4134 
    args.reason = reason
4135 
    args.write(self._oprot)
4136 
    self._oprot.writeMessageEnd()
4137 
    self._oprot.trans.flush()
4138 
 
4139 
  def recv_refundTransaction(self, ):
4140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4141 
    if mtype == TMessageType.EXCEPTION:
4142 
      x = TApplicationException()
4143 
      x.read(self._iprot)
4144 
      self._iprot.readMessageEnd()
4145 
      raise x
4146 
    result = refundTransaction_result()
4147 
    result.read(self._iprot)
4148 
    self._iprot.readMessageEnd()
4149 
    if result.ex is not None:
4150 
      raise result.ex
4151 
    return
4152 
 
4324 mandeep.dh 4153 
  def updateShipmentAddress(self, orderId, addressId):
4154 
    """
4155 
    Updates shipment address of an order. Delivery and shipping date estimates
4156 
    etc. are also updated here.
4157 
 
4158 
    Throws TransactionServiceException in case address change is not
4159 
    possible due to certain reasons such as new pincode in address is
4160 
    not serviceable etc.
4161 
 
4162 
    Parameters:
4163 
     - orderId
4164 
     - addressId
4165 
    """
4166 
    self.send_updateShipmentAddress(orderId, addressId)
4167 
    self.recv_updateShipmentAddress()
4168 
 
4169 
  def send_updateShipmentAddress(self, orderId, addressId):
4170 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4171 
    args = updateShipmentAddress_args()
4172 
    args.orderId = orderId
4173 
    args.addressId = addressId
4174 
    args.write(self._oprot)
4175 
    self._oprot.writeMessageEnd()
4176 
    self._oprot.trans.flush()
4177 
 
4178 
  def recv_updateShipmentAddress(self, ):
4179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4180 
    if mtype == TMessageType.EXCEPTION:
4181 
      x = TApplicationException()
4182 
      x.read(self._iprot)
4183 
      self._iprot.readMessageEnd()
4184 
      raise x
4185 
    result = updateShipmentAddress_result()
4186 
    result.read(self._iprot)
4187 
    self._iprot.readMessageEnd()
4188 
    if result.ex is not None:
4189 
      raise result.ex
4190 
    return
4191 
 
4285 rajveer 4192 
  def acceptOrdersForItemId(self, itemId, inventory):
4193 
    """
4194 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4195 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4196 
 
4285 rajveer 4197 
    Parameters:
4198 
     - itemId
4199 
     - inventory
4200 
    """
4201 
    self.send_acceptOrdersForItemId(itemId, inventory)
4202 
    return self.recv_acceptOrdersForItemId()
4203 
 
4204 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4205 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4206 
    args = acceptOrdersForItemId_args()
4207 
    args.itemId = itemId
4208 
    args.inventory = inventory
4209 
    args.write(self._oprot)
4210 
    self._oprot.writeMessageEnd()
4211 
    self._oprot.trans.flush()
4212 
 
4213 
  def recv_acceptOrdersForItemId(self, ):
4214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4215 
    if mtype == TMessageType.EXCEPTION:
4216 
      x = TApplicationException()
4217 
      x.read(self._iprot)
4218 
      self._iprot.readMessageEnd()
4219 
      raise x
4220 
    result = acceptOrdersForItemId_result()
4221 
    result.read(self._iprot)
4222 
    self._iprot.readMessageEnd()
4223 
    if result.success is not None:
4224 
      return result.success
4225 
    if result.ex is not None:
4226 
      raise result.ex
4227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4228 
 
4369 rajveer 4229 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4230 
    """
4231 
    Parameters:
4232 
     - vendorId
4233 
     - itemId
4234 
     - quantity
4235 
     - estimate
4369 rajveer 4236 
     - isReminder
4303 rajveer 4237 
    """
4369 rajveer 4238 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4239 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4240 
 
4369 rajveer 4241 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4242 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4243 
    args = markOrdersAsPORaised_args()
4244 
    args.vendorId = vendorId
4245 
    args.itemId = itemId
4246 
    args.quantity = quantity
4247 
    args.estimate = estimate
4369 rajveer 4248 
    args.isReminder = isReminder
4303 rajveer 4249 
    args.write(self._oprot)
4250 
    self._oprot.writeMessageEnd()
4251 
    self._oprot.trans.flush()
4252 
 
4253 
  def recv_markOrdersAsPORaised(self, ):
4254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4255 
    if mtype == TMessageType.EXCEPTION:
4256 
      x = TApplicationException()
4257 
      x.read(self._iprot)
4258 
      self._iprot.readMessageEnd()
4259 
      raise x
4260 
    result = markOrdersAsPORaised_result()
4261 
    result.read(self._iprot)
4262 
    self._iprot.readMessageEnd()
4263 
    if result.ex is not None:
4264 
      raise result.ex
4265 
    return
4266 
 
4369 rajveer 4267 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4268 
    """
4269 
    Parameters:
4270 
     - vendorId
4271 
     - itemId
4272 
     - quantity
4273 
     - estimate
4369 rajveer 4274 
     - isReminder
4303 rajveer 4275 
    """
4369 rajveer 4276 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4277 
    self.recv_markOrdersAsReversalInitiated()
4278 
 
4369 rajveer 4279 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4280 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4281 
    args = markOrdersAsReversalInitiated_args()
4282 
    args.vendorId = vendorId
4283 
    args.itemId = itemId
4284 
    args.quantity = quantity
4285 
    args.estimate = estimate
4369 rajveer 4286 
    args.isReminder = isReminder
4303 rajveer 4287 
    args.write(self._oprot)
4288 
    self._oprot.writeMessageEnd()
4289 
    self._oprot.trans.flush()
4290 
 
4291 
  def recv_markOrdersAsReversalInitiated(self, ):
4292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4293 
    if mtype == TMessageType.EXCEPTION:
4294 
      x = TApplicationException()
4295 
      x.read(self._iprot)
4296 
      self._iprot.readMessageEnd()
4297 
      raise x
4298 
    result = markOrdersAsReversalInitiated_result()
4299 
    result.read(self._iprot)
4300 
    self._iprot.readMessageEnd()
4301 
    if result.ex is not None:
4302 
      raise result.ex
4303 
    return
4304 
 
4369 rajveer 4305 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4306 
    """
4307 
    Parameters:
4308 
     - vendorId
4309 
     - itemId
4310 
     - quantity
4311 
     - estimate
4369 rajveer 4312 
     - isReminder
4303 rajveer 4313 
    """
4369 rajveer 4314 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4315 
    self.recv_markOrdersAsNotAvailabke()
4316 
 
4369 rajveer 4317 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4318 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4319 
    args = markOrdersAsNotAvailabke_args()
4320 
    args.vendorId = vendorId
4321 
    args.itemId = itemId
4322 
    args.quantity = quantity
4323 
    args.estimate = estimate
4369 rajveer 4324 
    args.isReminder = isReminder
4303 rajveer 4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_markOrdersAsNotAvailabke(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = markOrdersAsNotAvailabke_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    if result.ex is not None:
4340 
      raise result.ex
4341 
    return
4342 
 
4369 rajveer 4343 
  def markOrdersAsTimeout(self, vendorId):
4344 
    """
4345 
    Parameters:
4346 
     - vendorId
4347 
    """
4348 
    self.send_markOrdersAsTimeout(vendorId)
4349 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4350 
 
4369 rajveer 4351 
  def send_markOrdersAsTimeout(self, vendorId):
4352 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4353 
    args = markOrdersAsTimeout_args()
4354 
    args.vendorId = vendorId
4355 
    args.write(self._oprot)
4356 
    self._oprot.writeMessageEnd()
4357 
    self._oprot.trans.flush()
4358 
 
4359 
  def recv_markOrdersAsTimeout(self, ):
4360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4361 
    if mtype == TMessageType.EXCEPTION:
4362 
      x = TApplicationException()
4363 
      x.read(self._iprot)
4364 
      self._iprot.readMessageEnd()
4365 
      raise x
4366 
    result = markOrdersAsTimeout_result()
4367 
    result.read(self._iprot)
4368 
    self._iprot.readMessageEnd()
4369 
    if result.success is not None:
4370 
      return result.success
4371 
    if result.ex is not None:
4372 
      raise result.ex
4373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4374 
 
4662 rajveer 4375 
  def markOrderAsLostInTransit(self, orderId):
4376 
    """
4377 
    Mark order as LOST_IN_TRANSIT
4378 
 
4379 
    Parameters:
4380 
     - orderId
4381 
    """
4382 
    self.send_markOrderAsLostInTransit(orderId)
4383 
    return self.recv_markOrderAsLostInTransit()
4384 
 
4385 
  def send_markOrderAsLostInTransit(self, orderId):
4386 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4387 
    args = markOrderAsLostInTransit_args()
4388 
    args.orderId = orderId
4389 
    args.write(self._oprot)
4390 
    self._oprot.writeMessageEnd()
4391 
    self._oprot.trans.flush()
4392 
 
4393 
  def recv_markOrderAsLostInTransit(self, ):
4394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4395 
    if mtype == TMessageType.EXCEPTION:
4396 
      x = TApplicationException()
4397 
      x.read(self._iprot)
4398 
      self._iprot.readMessageEnd()
4399 
      raise x
4400 
    result = markOrderAsLostInTransit_result()
4401 
    result.read(self._iprot)
4402 
    self._iprot.readMessageEnd()
4403 
    if result.success is not None:
4404 
      return result.success
4405 
    if result.ex is not None:
4406 
      raise result.ex
4407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4408 
 
4386 anupam.sin 4409 
  def getOrderForAwb(self, awb):
4410 
    """
4411 
    Returns the order corresponding to an AWB number
4369 rajveer 4412 
 
4386 anupam.sin 4413 
    Parameters:
4414 
     - awb
4415 
    """
4416 
    self.send_getOrderForAwb(awb)
4417 
    return self.recv_getOrderForAwb()
4418 
 
4419 
  def send_getOrderForAwb(self, awb):
4420 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4421 
    args = getOrderForAwb_args()
4422 
    args.awb = awb
4423 
    args.write(self._oprot)
4424 
    self._oprot.writeMessageEnd()
4425 
    self._oprot.trans.flush()
4426 
 
4427 
  def recv_getOrderForAwb(self, ):
4428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4429 
    if mtype == TMessageType.EXCEPTION:
4430 
      x = TApplicationException()
4431 
      x.read(self._iprot)
4432 
      self._iprot.readMessageEnd()
4433 
      raise x
4434 
    result = getOrderForAwb_result()
4435 
    result.read(self._iprot)
4436 
    self._iprot.readMessageEnd()
4437 
    if result.success is not None:
4438 
      return result.success
4439 
    if result.ex is not None:
4440 
      raise result.ex
4441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4442 
 
4910 phani.kuma 4443 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4444 
    """
4910 phani.kuma 4445 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4446 
 
4506 phani.kuma 4447 
    Parameters:
4448 
     - logistics_provider_id
4910 phani.kuma 4449 
     - order_status_list
4506 phani.kuma 4450 
    """
4910 phani.kuma 4451 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4452 
    return self.recv_getOrdersForProviderForStatus()
4453 
 
4910 phani.kuma 4454 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4455 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4456 
    args = getOrdersForProviderForStatus_args()
4457 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4458 
    args.order_status_list = order_status_list
4506 phani.kuma 4459 
    args.write(self._oprot)
4460 
    self._oprot.writeMessageEnd()
4461 
    self._oprot.trans.flush()
4462 
 
4463 
  def recv_getOrdersForProviderForStatus(self, ):
4464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4465 
    if mtype == TMessageType.EXCEPTION:
4466 
      x = TApplicationException()
4467 
      x.read(self._iprot)
4468 
      self._iprot.readMessageEnd()
4469 
      raise x
4470 
    result = getOrdersForProviderForStatus_result()
4471 
    result.read(self._iprot)
4472 
    self._iprot.readMessageEnd()
4473 
    if result.success is not None:
4474 
      return result.success
4475 
    if result.ex is not None:
4476 
      raise result.ex
4477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4478 
 
4600 varun.gupt 4479 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4480 
    """
4481 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4482 
 
4600 varun.gupt 4483 
    Parameters:
4484 
     - vendorId
4485 
     - billingDateFrom
4486 
     - billingDateTo
4487 
    """
4488 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4489 
    return self.recv_getBilledOrdersForVendor()
4490 
 
4491 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4492 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4493 
    args = getBilledOrdersForVendor_args()
4494 
    args.vendorId = vendorId
4495 
    args.billingDateFrom = billingDateFrom
4496 
    args.billingDateTo = billingDateTo
4497 
    args.write(self._oprot)
4498 
    self._oprot.writeMessageEnd()
4499 
    self._oprot.trans.flush()
4500 
 
4501 
  def recv_getBilledOrdersForVendor(self, ):
4502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4503 
    if mtype == TMessageType.EXCEPTION:
4504 
      x = TApplicationException()
4505 
      x.read(self._iprot)
4506 
      self._iprot.readMessageEnd()
4507 
      raise x
4508 
    result = getBilledOrdersForVendor_result()
4509 
    result.read(self._iprot)
4510 
    self._iprot.readMessageEnd()
4511 
    if result.success is not None:
4512 
      return result.success
4513 
    if result.ex is not None:
4514 
      raise result.ex
4515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4516 
 
4607 rajveer 4517 
  def getSlippedSippingDateOrders(self, ):
4518 
    self.send_getSlippedSippingDateOrders()
4519 
    return self.recv_getSlippedSippingDateOrders()
4520 
 
4521 
  def send_getSlippedSippingDateOrders(self, ):
4522 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4523 
    args = getSlippedSippingDateOrders_args()
4524 
    args.write(self._oprot)
4525 
    self._oprot.writeMessageEnd()
4526 
    self._oprot.trans.flush()
4527 
 
4528 
  def recv_getSlippedSippingDateOrders(self, ):
4529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4530 
    if mtype == TMessageType.EXCEPTION:
4531 
      x = TApplicationException()
4532 
      x.read(self._iprot)
4533 
      self._iprot.readMessageEnd()
4534 
      raise x
4535 
    result = getSlippedSippingDateOrders_result()
4536 
    result.read(self._iprot)
4537 
    self._iprot.readMessageEnd()
4538 
    if result.success is not None:
4539 
      return result.success
4540 
    if result.ex is not None:
4541 
      raise result.ex
4542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4543 
 
4709 rajveer 4544 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4545 
    """
4546 
    Parameters:
4547 
     - cancelDateFrom
4548 
     - cancelDateTo
4549 
    """
4550 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4551 
    return self.recv_getCancelledOrders()
4552 
 
4553 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4554 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4555 
    args = getCancelledOrders_args()
4556 
    args.cancelDateFrom = cancelDateFrom
4557 
    args.cancelDateTo = cancelDateTo
4558 
    args.write(self._oprot)
4559 
    self._oprot.writeMessageEnd()
4560 
    self._oprot.trans.flush()
4561 
 
4562 
  def recv_getCancelledOrders(self, ):
4563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4564 
    if mtype == TMessageType.EXCEPTION:
4565 
      x = TApplicationException()
4566 
      x.read(self._iprot)
4567 
      self._iprot.readMessageEnd()
4568 
      raise x
4569 
    result = getCancelledOrders_result()
4570 
    result.read(self._iprot)
4571 
    self._iprot.readMessageEnd()
4572 
    if result.success is not None:
4573 
      return result.success
4574 
    if result.ex is not None:
4575 
      raise result.ex
4576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4577 
 
4600 varun.gupt 4578 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4579 
    """
4580 
    Parameters:
4581 
     - mapAWBAndAmount
4582 
    """
4583 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4584 
    self.recv_saveBluedartSettlements()
4585 
 
4586 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4587 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4588 
    args = saveBluedartSettlements_args()
4589 
    args.mapAWBAndAmount = mapAWBAndAmount
4590 
    args.write(self._oprot)
4591 
    self._oprot.writeMessageEnd()
4592 
    self._oprot.trans.flush()
4593 
 
4594 
  def recv_saveBluedartSettlements(self, ):
4595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4596 
    if mtype == TMessageType.EXCEPTION:
4597 
      x = TApplicationException()
4598 
      x.read(self._iprot)
4599 
      self._iprot.readMessageEnd()
4600 
      raise x
4601 
    result = saveBluedartSettlements_result()
4602 
    result.read(self._iprot)
4603 
    self._iprot.readMessageEnd()
4604 
    if result.ex is not None:
4605 
      raise result.ex
4606 
    return
4607 
 
4905 varun.gupt 4608 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4609 
    """
4610 
    Parameters:
4611 
     - settlementDate
4612 
     - paymentGatewayId
4905 varun.gupt 4613 
     - referenceId
4600 varun.gupt 4614 
     - serviceTax
4615 
     - otherCharges
4616 
     - netCollection
4617 
    """
4905 varun.gupt 4618 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4619 
    self.recv_savePaymentSettlements()
4620 
 
4905 varun.gupt 4621 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4622 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4623 
    args = savePaymentSettlements_args()
4624 
    args.settlementDate = settlementDate
4625 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4626 
    args.referenceId = referenceId
4600 varun.gupt 4627 
    args.serviceTax = serviceTax
4628 
    args.otherCharges = otherCharges
4629 
    args.netCollection = netCollection
4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
4634 
  def recv_savePaymentSettlements(self, ):
4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
4641 
    result = savePaymentSettlements_result()
4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.ex is not None:
4645 
      raise result.ex
4646 
    return
4647 
 
4648 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4649 
    """
4650 
    Parameters:
4651 
     - settlementId
4652 
     - settlementDate
4653 
     - transactionDateFrom
4654 
     - transactionDateTo
4655 
     - amount
4656 
    """
4657 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4658 
    self.recv_saveEBSSettlementSummary()
4659 
 
4660 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4661 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4662 
    args = saveEBSSettlementSummary_args()
4663 
    args.settlementId = settlementId
4664 
    args.settlementDate = settlementDate
4665 
    args.transactionDateFrom = transactionDateFrom
4666 
    args.transactionDateTo = transactionDateTo
4667 
    args.amount = amount
4668 
    args.write(self._oprot)
4669 
    self._oprot.writeMessageEnd()
4670 
    self._oprot.trans.flush()
4671 
 
4672 
  def recv_saveEBSSettlementSummary(self, ):
4673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4674 
    if mtype == TMessageType.EXCEPTION:
4675 
      x = TApplicationException()
4676 
      x.read(self._iprot)
4677 
      self._iprot.readMessageEnd()
4678 
      raise x
4679 
    result = saveEBSSettlementSummary_result()
4680 
    result.read(self._iprot)
4681 
    self._iprot.readMessageEnd()
4682 
    if result.ex is not None:
4683 
      raise result.ex
4684 
    return
4685 
 
5386 phani.kuma 4686 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4687 
    """
4688 
    Parameters:
5189 varun.gupt 4689 
     - referenceId
4690 
     - isRefund
4600 varun.gupt 4691 
    """
5386 phani.kuma 4692 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4693 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4694 
 
5386 phani.kuma 4695 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4696 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4697 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4698 
    args.referenceId = referenceId
4699 
    args.isRefund = isRefund
4600 varun.gupt 4700 
    args.write(self._oprot)
4701 
    self._oprot.writeMessageEnd()
4702 
    self._oprot.trans.flush()
4703 
 
5386 phani.kuma 4704 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4706 
    if mtype == TMessageType.EXCEPTION:
4707 
      x = TApplicationException()
4708 
      x.read(self._iprot)
4709 
      self._iprot.readMessageEnd()
4710 
      raise x
5386 phani.kuma 4711 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4712 
    result.read(self._iprot)
4713 
    self._iprot.readMessageEnd()
4714 
    if result.success is not None:
4715 
      return result.success
4716 
    if result.ex is not None:
4717 
      raise result.ex
5386 phani.kuma 4718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4719 
 
5386 phani.kuma 4720 
  def getSettlementForCod(self, orderId, isRefund):
4721 
    """
4722 
    Parameters:
4723 
     - orderId
4724 
     - isRefund
4725 
    """
4726 
    self.send_getSettlementForCod(orderId, isRefund)
4727 
    return self.recv_getSettlementForCod()
4728 
 
4729 
  def send_getSettlementForCod(self, orderId, isRefund):
4730 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4731 
    args = getSettlementForCod_args()
4732 
    args.orderId = orderId
4733 
    args.isRefund = isRefund
4734 
    args.write(self._oprot)
4735 
    self._oprot.writeMessageEnd()
4736 
    self._oprot.trans.flush()
4737 
 
4738 
  def recv_getSettlementForCod(self, ):
4739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4740 
    if mtype == TMessageType.EXCEPTION:
4741 
      x = TApplicationException()
4742 
      x.read(self._iprot)
4743 
      self._iprot.readMessageEnd()
4744 
      raise x
4745 
    result = getSettlementForCod_result()
4746 
    result.read(self._iprot)
4747 
    self._iprot.readMessageEnd()
4748 
    if result.success is not None:
4749 
      return result.success
4750 
    if result.ex is not None:
4751 
      raise result.ex
4752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4753 
 
4600 varun.gupt 4754 
  def getEBSSettlementSummaries(self, ):
4755 
    self.send_getEBSSettlementSummaries()
4756 
    return self.recv_getEBSSettlementSummaries()
4757 
 
4758 
  def send_getEBSSettlementSummaries(self, ):
4759 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4760 
    args = getEBSSettlementSummaries_args()
4761 
    args.write(self._oprot)
4762 
    self._oprot.writeMessageEnd()
4763 
    self._oprot.trans.flush()
4764 
 
4765 
  def recv_getEBSSettlementSummaries(self, ):
4766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4767 
    if mtype == TMessageType.EXCEPTION:
4768 
      x = TApplicationException()
4769 
      x.read(self._iprot)
4770 
      self._iprot.readMessageEnd()
4771 
      raise x
4772 
    result = getEBSSettlementSummaries_result()
4773 
    result.read(self._iprot)
4774 
    self._iprot.readMessageEnd()
4775 
    if result.success is not None:
4776 
      return result.success
4777 
    if result.ex is not None:
4778 
      raise result.ex
4779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4780 
 
4781 
  def markEBSSettlementUploaded(self, settlementId):
4782 
    """
4783 
    Parameters:
4784 
     - settlementId
4785 
    """
4786 
    self.send_markEBSSettlementUploaded(settlementId)
4787 
    self.recv_markEBSSettlementUploaded()
4788 
 
4789 
  def send_markEBSSettlementUploaded(self, settlementId):
4790 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4791 
    args = markEBSSettlementUploaded_args()
4792 
    args.settlementId = settlementId
4793 
    args.write(self._oprot)
4794 
    self._oprot.writeMessageEnd()
4795 
    self._oprot.trans.flush()
4796 
 
4797 
  def recv_markEBSSettlementUploaded(self, ):
4798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4799 
    if mtype == TMessageType.EXCEPTION:
4800 
      x = TApplicationException()
4801 
      x.read(self._iprot)
4802 
      self._iprot.readMessageEnd()
4803 
      raise x
4804 
    result = markEBSSettlementUploaded_result()
4805 
    result.read(self._iprot)
4806 
    self._iprot.readMessageEnd()
4807 
    if result.ex is not None:
4808 
      raise result.ex
4809 
    return
4810 
 
4811 
  def getEBSSettlementDate(self, settlementId):
4812 
    """
4813 
    Parameters:
4814 
     - settlementId
4815 
    """
4816 
    self.send_getEBSSettlementDate(settlementId)
4817 
    return self.recv_getEBSSettlementDate()
4818 
 
4819 
  def send_getEBSSettlementDate(self, settlementId):
4820 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4821 
    args = getEBSSettlementDate_args()
4822 
    args.settlementId = settlementId
4823 
    args.write(self._oprot)
4824 
    self._oprot.writeMessageEnd()
4825 
    self._oprot.trans.flush()
4826 
 
4827 
  def recv_getEBSSettlementDate(self, ):
4828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4829 
    if mtype == TMessageType.EXCEPTION:
4830 
      x = TApplicationException()
4831 
      x.read(self._iprot)
4832 
      self._iprot.readMessageEnd()
4833 
      raise x
4834 
    result = getEBSSettlementDate_result()
4835 
    result.read(self._iprot)
4836 
    self._iprot.readMessageEnd()
4837 
    if result.success is not None:
4838 
      return result.success
4839 
    if result.ex is not None:
4840 
      raise result.ex
4841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4842 
 
4715 varun.gupt 4843 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4844 
    """
4845 
    Parameters:
4846 
     - settlementDateFrom
4847 
     - settlementDateTo
4848 
     - isRefund
4849 
    """
4850 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4851 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4852 
 
4715 varun.gupt 4853 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4854 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4855 
    args = getSettlementsByDate_args()
4856 
    args.settlementDateFrom = settlementDateFrom
4857 
    args.settlementDateTo = settlementDateTo
4858 
    args.isRefund = isRefund
4859 
    args.write(self._oprot)
4860 
    self._oprot.writeMessageEnd()
4861 
    self._oprot.trans.flush()
4862 
 
4863 
  def recv_getSettlementsByDate(self, ):
4864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4865 
    if mtype == TMessageType.EXCEPTION:
4866 
      x = TApplicationException()
4867 
      x.read(self._iprot)
4868 
      self._iprot.readMessageEnd()
4869 
      raise x
4870 
    result = getSettlementsByDate_result()
4871 
    result.read(self._iprot)
4872 
    self._iprot.readMessageEnd()
4873 
    if result.success is not None:
4874 
      return result.success
4875 
    if result.ex is not None:
4876 
      raise result.ex
4877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4878 
 
4879 
  def getReshippedOrderIds(self, orderIds):
4880 
    """
4881 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4882 
 
4883 
    Parameters:
4884 
     - orderIds
4885 
    """
4886 
    self.send_getReshippedOrderIds(orderIds)
4887 
    return self.recv_getReshippedOrderIds()
4888 
 
4889 
  def send_getReshippedOrderIds(self, orderIds):
4890 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4891 
    args = getReshippedOrderIds_args()
4892 
    args.orderIds = orderIds
4893 
    args.write(self._oprot)
4894 
    self._oprot.writeMessageEnd()
4895 
    self._oprot.trans.flush()
4896 
 
4897 
  def recv_getReshippedOrderIds(self, ):
4898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4899 
    if mtype == TMessageType.EXCEPTION:
4900 
      x = TApplicationException()
4901 
      x.read(self._iprot)
4902 
      self._iprot.readMessageEnd()
4903 
      raise x
4904 
    result = getReshippedOrderIds_result()
4905 
    result.read(self._iprot)
4906 
    self._iprot.readMessageEnd()
4907 
    if result.success is not None:
4908 
      return result.success
4909 
    if result.ex is not None:
4910 
      raise result.ex
4911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4912 
 
4875 varun.gupt 4913 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4914 
    """
4915 
    Parameters:
4916 
     - vendorId
4917 
    """
4918 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4919 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4920 
 
4875 varun.gupt 4921 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4922 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4923 
    args = getOrdersWhereVendorNotPaid_args()
4924 
    args.vendorId = vendorId
4925 
    args.write(self._oprot)
4926 
    self._oprot.writeMessageEnd()
4927 
    self._oprot.trans.flush()
4928 
 
4929 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4931 
    if mtype == TMessageType.EXCEPTION:
4932 
      x = TApplicationException()
4933 
      x.read(self._iprot)
4934 
      self._iprot.readMessageEnd()
4935 
      raise x
4936 
    result = getOrdersWhereVendorNotPaid_result()
4937 
    result.read(self._iprot)
4938 
    self._iprot.readMessageEnd()
4939 
    if result.success is not None:
4940 
      return result.success
4941 
    if result.ex is not None:
4942 
      raise result.ex
4943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4944 
 
5031 varun.gupt 4945 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4946 
    """
4947 
    Parameters:
4948 
     - startDate
4949 
     - endDate
4950 
    """
4951 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4952 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4953 
 
5031 varun.gupt 4954 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4955 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4956 
    args = getStatusDistributionOfOrders_args()
4957 
    args.startDate = startDate
4958 
    args.endDate = endDate
4959 
    args.write(self._oprot)
4960 
    self._oprot.writeMessageEnd()
4961 
    self._oprot.trans.flush()
4962 
 
4963 
  def recv_getStatusDistributionOfOrders(self, ):
4964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4965 
    if mtype == TMessageType.EXCEPTION:
4966 
      x = TApplicationException()
4967 
      x.read(self._iprot)
4968 
      self._iprot.readMessageEnd()
4969 
      raise x
4970 
    result = getStatusDistributionOfOrders_result()
4971 
    result.read(self._iprot)
4972 
    self._iprot.readMessageEnd()
4973 
    if result.success is not None:
4974 
      return result.success
4975 
    if result.ex is not None:
4976 
      raise result.ex
4977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4978 
 
5067 varun.gupt 4979 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4980 
    """
4981 
    Parameters:
4982 
     - status
4983 
     - startDatetime
4984 
     - endDatetime
4985 
    """
4986 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4987 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4988 
 
5067 varun.gupt 4989 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4990 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4991 
    args = getOrderIdsForStatus_args()
4992 
    args.status = status
4993 
    args.startDatetime = startDatetime
4994 
    args.endDatetime = endDatetime
4995 
    args.write(self._oprot)
4996 
    self._oprot.writeMessageEnd()
4997 
    self._oprot.trans.flush()
4998 
 
4999 
  def recv_getOrderIdsForStatus(self, ):
5000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5001 
    if mtype == TMessageType.EXCEPTION:
5002 
      x = TApplicationException()
5003 
      x.read(self._iprot)
5004 
      self._iprot.readMessageEnd()
5005 
      raise x
5006 
    result = getOrderIdsForStatus_result()
5007 
    result.read(self._iprot)
5008 
    self._iprot.readMessageEnd()
5009 
    if result.success is not None:
5010 
      return result.success
5011 
    if result.ex is not None:
5012 
      raise result.ex
5013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5014 
 
5348 anupam.sin 5015 
  def updateCODAgent(self, agent, orderId):
5016 
    """
5017 
    Updates the agent who handled the COD verification call
5018 
 
5019 
    Parameters:
5020 
     - agent
5021 
     - orderId
5022 
    """
5023 
    self.send_updateCODAgent(agent, orderId)
5024 
    self.recv_updateCODAgent()
5025 
 
5026 
  def send_updateCODAgent(self, agent, orderId):
5027 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5028 
    args = updateCODAgent_args()
5029 
    args.agent = agent
5030 
    args.orderId = orderId
5031 
    args.write(self._oprot)
5032 
    self._oprot.writeMessageEnd()
5033 
    self._oprot.trans.flush()
5034 
 
5035 
  def recv_updateCODAgent(self, ):
5036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5037 
    if mtype == TMessageType.EXCEPTION:
5038 
      x = TApplicationException()
5039 
      x.read(self._iprot)
5040 
      self._iprot.readMessageEnd()
5041 
      raise x
5042 
    result = updateCODAgent_result()
5043 
    result.read(self._iprot)
5044 
    self._iprot.readMessageEnd()
5045 
    if result.ex is not None:
5046 
      raise result.ex
5047 
    return
5048 
 
5099 varun.gupt 5049 
  def updateOrderAsPaidToVendor(self, orderId):
5050 
    """
5051 
    Parameters:
5052 
     - orderId
5053 
    """
5054 
    self.send_updateOrderAsPaidToVendor(orderId)
5055 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5056 
 
5099 varun.gupt 5057 
  def send_updateOrderAsPaidToVendor(self, orderId):
5058 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5059 
    args = updateOrderAsPaidToVendor_args()
5060 
    args.orderId = orderId
5061 
    args.write(self._oprot)
5062 
    self._oprot.writeMessageEnd()
5063 
    self._oprot.trans.flush()
5064 
 
5065 
  def recv_updateOrderAsPaidToVendor(self, ):
5066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5067 
    if mtype == TMessageType.EXCEPTION:
5068 
      x = TApplicationException()
5069 
      x.read(self._iprot)
5070 
      self._iprot.readMessageEnd()
5071 
      raise x
5072 
    result = updateOrderAsPaidToVendor_result()
5073 
    result.read(self._iprot)
5074 
    self._iprot.readMessageEnd()
5075 
    if result.ex is not None:
5076 
      raise result.ex
5077 
    return
5078 
 
5386 phani.kuma 5079 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5080 
    """
5081 
    Parameters:
5082 
     - orderId
5083 
    """
5084 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5085 
    self.recv_updateOrderOnlyAsPaidToVendor()
5086 
 
5087 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5088 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5089 
    args = updateOrderOnlyAsPaidToVendor_args()
5090 
    args.orderId = orderId
5091 
    args.write(self._oprot)
5092 
    self._oprot.writeMessageEnd()
5093 
    self._oprot.trans.flush()
5094 
 
5095 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5097 
    if mtype == TMessageType.EXCEPTION:
5098 
      x = TApplicationException()
5099 
      x.read(self._iprot)
5100 
      self._iprot.readMessageEnd()
5101 
      raise x
5102 
    result = updateOrderOnlyAsPaidToVendor_result()
5103 
    result.read(self._iprot)
5104 
    self._iprot.readMessageEnd()
5105 
    if result.ex is not None:
5106 
      raise result.ex
5107 
    return
5108 
 
5208 varun.gupt 5109 
  def getRefundedOrdersMarkedPaid(self, ):
5110 
    self.send_getRefundedOrdersMarkedPaid()
5111 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5112 
 
5208 varun.gupt 5113 
  def send_getRefundedOrdersMarkedPaid(self, ):
5114 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5115 
    args = getRefundedOrdersMarkedPaid_args()
5116 
    args.write(self._oprot)
5117 
    self._oprot.writeMessageEnd()
5118 
    self._oprot.trans.flush()
5119 
 
5120 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5122 
    if mtype == TMessageType.EXCEPTION:
5123 
      x = TApplicationException()
5124 
      x.read(self._iprot)
5125 
      self._iprot.readMessageEnd()
5126 
      raise x
5127 
    result = getRefundedOrdersMarkedPaid_result()
5128 
    result.read(self._iprot)
5129 
    self._iprot.readMessageEnd()
5130 
    if result.success is not None:
5131 
      return result.success
5132 
    if result.ex is not None:
5133 
      raise result.ex
5134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5135 
 
5447 anupam.sin 5136 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5137 
    """
5138 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5139 
 
5447 anupam.sin 5140 
 
5141 
    Parameters:
5142 
     - minOrderId
5143 
     - maxOrderId
5144 
    """
5145 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5146 
    return self.recv_getAllVerificationAgents()
5147 
 
5148 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5149 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5150 
    args = getAllVerificationAgents_args()
5151 
    args.minOrderId = minOrderId
5152 
    args.maxOrderId = maxOrderId
5153 
    args.write(self._oprot)
5154 
    self._oprot.writeMessageEnd()
5155 
    self._oprot.trans.flush()
5156 
 
5157 
  def recv_getAllVerificationAgents(self, ):
5158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5159 
    if mtype == TMessageType.EXCEPTION:
5160 
      x = TApplicationException()
5161 
      x.read(self._iprot)
5162 
      self._iprot.readMessageEnd()
5163 
      raise x
5164 
    result = getAllVerificationAgents_result()
5165 
    result.read(self._iprot)
5166 
    self._iprot.readMessageEnd()
5167 
    if result.success is not None:
5168 
      return result.success
5169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5170 
 
5171 
 
3376 rajveer 5172 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5173 
  def __init__(self, handler):
3376 rajveer 5174 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5175 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5176 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5177 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5178 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5179 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5180 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5181 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5182 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5183 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5184 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5185 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5186 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5187 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5188 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5189 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5190 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5191 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5192 
    self._processMap["createOrder"] = Processor.process_createOrder
5193 
    self._processMap["getOrder"] = Processor.process_getOrder
5194 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5195 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5196 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5197 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5198 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5199 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5200 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5201 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5202 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5203 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5204 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5205 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5206 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5207 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5208 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5209 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5210 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5211 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5212 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5213 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5214 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5215 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5216 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5217 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5218 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5219 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5220 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5221 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5222 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5223 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5224 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5225 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5226 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5227 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5228 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5229 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5230 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5231 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5232 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5233 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5234 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5235 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5236 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5237 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5238 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5239 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5240 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5241 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5242 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5243 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5244 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5245 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5246 
    self._processMap["changeItem"] = Processor.process_changeItem
5247 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5248 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5249 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5250 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5251 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5252 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5253 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5254 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5255 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5256 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5257 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5258 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5259 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5260 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5261 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5262 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5263 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5264 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5265 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5266 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5267 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5268 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5269 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5270 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5271 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5272 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5273 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5274 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5275 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5276 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5277 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5278 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5279 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5280 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4875 varun.gupt 5281 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5282 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5283 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5284 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5285 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5286 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5287 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5288 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
94 ashish 5289 
 
5290 
  def process(self, iprot, oprot):
5291 
    (name, type, seqid) = iprot.readMessageBegin()
5292 
    if name not in self._processMap:
5293 
      iprot.skip(TType.STRUCT)
5294 
      iprot.readMessageEnd()
5295 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5296 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5297 
      x.write(oprot)
5298 
      oprot.writeMessageEnd()
5299 
      oprot.trans.flush()
5300 
      return
5301 
    else:
5302 
      self._processMap[name](self, seqid, iprot, oprot)
5303 
    return True
5304 
 
5305 
  def process_createTransaction(self, seqid, iprot, oprot):
5306 
    args = createTransaction_args()
5307 
    args.read(iprot)
5308 
    iprot.readMessageEnd()
5309 
    result = createTransaction_result()
5310 
    try:
132 ashish 5311 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5312 
    except TransactionServiceException, ex:
5313 
      result.ex = ex
5314 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5315 
    result.write(oprot)
5316 
    oprot.writeMessageEnd()
5317 
    oprot.trans.flush()
5318 
 
5319 
  def process_getTransaction(self, seqid, iprot, oprot):
5320 
    args = getTransaction_args()
5321 
    args.read(iprot)
5322 
    iprot.readMessageEnd()
5323 
    result = getTransaction_result()
5324 
    try:
5325 
      result.success = self._handler.getTransaction(args.id)
5326 
    except TransactionServiceException, ex:
5327 
      result.ex = ex
5328 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5329 
    result.write(oprot)
5330 
    oprot.writeMessageEnd()
5331 
    oprot.trans.flush()
5332 
 
5333 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5334 
    args = getTransactionsForCustomer_args()
5335 
    args.read(iprot)
5336 
    iprot.readMessageEnd()
5337 
    result = getTransactionsForCustomer_result()
5338 
    try:
5339 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5340 
    except TransactionServiceException, ex:
5341 
      result.ex = ex
5342 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5343 
    result.write(oprot)
5344 
    oprot.writeMessageEnd()
5345 
    oprot.trans.flush()
5346 
 
132 ashish 5347 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5348 
    args = getTransactionsForShoppingCartId_args()
5349 
    args.read(iprot)
5350 
    iprot.readMessageEnd()
5351 
    result = getTransactionsForShoppingCartId_result()
5352 
    try:
5353 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5354 
    except TransactionServiceException, ex:
5355 
      result.ex = ex
5356 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5357 
    result.write(oprot)
5358 
    oprot.writeMessageEnd()
5359 
    oprot.trans.flush()
5360 
 
94 ashish 5361 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5362 
    args = getTransactionStatus_args()
5363 
    args.read(iprot)
5364 
    iprot.readMessageEnd()
5365 
    result = getTransactionStatus_result()
5366 
    try:
5367 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5368 
    except TransactionServiceException, ex:
5369 
      result.ex = ex
5370 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5371 
    result.write(oprot)
5372 
    oprot.writeMessageEnd()
5373 
    oprot.trans.flush()
5374 
 
5375 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5376 
    args = changeTransactionStatus_args()
5377 
    args.read(iprot)
5378 
    iprot.readMessageEnd()
5379 
    result = changeTransactionStatus_result()
5380 
    try:
5387 rajveer 5381 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.selfPickup)
94 ashish 5382 
    except TransactionServiceException, ex:
5383 
      result.ex = ex
5384 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5385 
    result.write(oprot)
5386 
    oprot.writeMessageEnd()
5387 
    oprot.trans.flush()
5388 
 
1398 varun.gupt 5389 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5390 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5391 
    args.read(iprot)
5392 
    iprot.readMessageEnd()
1398 varun.gupt 5393 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5394 
    try:
1398 varun.gupt 5395 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5396 
    except TransactionServiceException, ex:
5397 
      result.ex = ex
1398 varun.gupt 5398 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5399 
    result.write(oprot)
5400 
    oprot.writeMessageEnd()
5401 
    oprot.trans.flush()
5402 
 
483 rajveer 5403 
  def process_getAllOrders(self, seqid, iprot, oprot):
5404 
    args = getAllOrders_args()
94 ashish 5405 
    args.read(iprot)
5406 
    iprot.readMessageEnd()
483 rajveer 5407 
    result = getAllOrders_result()
94 ashish 5408 
    try:
4801 anupam.sin 5409 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5410 
    except TransactionServiceException, ex:
5411 
      result.ex = ex
483 rajveer 5412 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5413 
    result.write(oprot)
5414 
    oprot.writeMessageEnd()
5415 
    oprot.trans.flush()
5416 
 
4133 chandransh 5417 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5418 
    args = getOrdersInBatch_args()
5419 
    args.read(iprot)
5420 
    iprot.readMessageEnd()
5421 
    result = getOrdersInBatch_result()
5422 
    try:
5423 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5424 
    except TransactionServiceException, ex:
5425 
      result.ex = ex
5426 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5427 
    result.write(oprot)
5428 
    oprot.writeMessageEnd()
5429 
    oprot.trans.flush()
5430 
 
5431 
  def process_getOrderCount(self, seqid, iprot, oprot):
5432 
    args = getOrderCount_args()
5433 
    args.read(iprot)
5434 
    iprot.readMessageEnd()
5435 
    result = getOrderCount_result()
5436 
    try:
5437 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5438 
    except TransactionServiceException, ex:
5439 
      result.ex = ex
5440 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5441 
    result.write(oprot)
5442 
    oprot.writeMessageEnd()
5443 
    oprot.trans.flush()
5444 
 
999 varun.gupt 5445 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5446 
    args = getOrdersByBillingDate_args()
5447 
    args.read(iprot)
5448 
    iprot.readMessageEnd()
5449 
    result = getOrdersByBillingDate_result()
5450 
    try:
5451 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5452 
    except TransactionServiceException, ex:
5453 
      result.ex = ex
5454 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5455 
    result.write(oprot)
5456 
    oprot.writeMessageEnd()
5457 
    oprot.trans.flush()
5458 
 
3427 chandransh 5459 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5460 
    args = getOrdersByShippingDate_args()
5461 
    args.read(iprot)
5462 
    iprot.readMessageEnd()
5463 
    result = getOrdersByShippingDate_result()
5464 
    try:
3451 chandransh 5465 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5466 
    except TransactionServiceException, ex:
5467 
      result.ex = ex
5468 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5469 
    result.write(oprot)
5470 
    oprot.writeMessageEnd()
5471 
    oprot.trans.flush()
5472 
 
1382 varun.gupt 5473 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5474 
    args = getReturnableOrdersForCustomer_args()
5475 
    args.read(iprot)
5476 
    iprot.readMessageEnd()
5477 
    result = getReturnableOrdersForCustomer_result()
5478 
    try:
5479 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5480 
    except TransactionServiceException, ex:
5481 
      result.ex = ex
5482 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5483 
    result.write(oprot)
5484 
    oprot.writeMessageEnd()
5485 
    oprot.trans.flush()
5486 
 
5487 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5488 
    args = getCancellableOrdersForCustomer_args()
5489 
    args.read(iprot)
5490 
    iprot.readMessageEnd()
5491 
    result = getCancellableOrdersForCustomer_result()
5492 
    try:
5493 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5494 
    except TransactionServiceException, ex:
5495 
      result.ex = ex
5496 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5497 
    result.write(oprot)
5498 
    oprot.writeMessageEnd()
5499 
    oprot.trans.flush()
5500 
 
483 rajveer 5501 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5502 
    args = changeOrderStatus_args()
94 ashish 5503 
    args.read(iprot)
5504 
    iprot.readMessageEnd()
483 rajveer 5505 
    result = changeOrderStatus_result()
94 ashish 5506 
    try:
483 rajveer 5507 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5508 
    except TransactionServiceException, ex:
5509 
      result.ex = ex
483 rajveer 5510 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5511 
    result.write(oprot)
5512 
    oprot.writeMessageEnd()
5513 
    oprot.trans.flush()
5514 
 
483 rajveer 5515 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5516 
    args = getOrdersForTransaction_args()
94 ashish 5517 
    args.read(iprot)
5518 
    iprot.readMessageEnd()
483 rajveer 5519 
    result = getOrdersForTransaction_result()
94 ashish 5520 
    try:
1528 ankur.sing 5521 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5522 
    except TransactionServiceException, ex:
5523 
      result.ex = ex
483 rajveer 5524 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5525 
    result.write(oprot)
5526 
    oprot.writeMessageEnd()
5527 
    oprot.trans.flush()
5528 
 
483 rajveer 5529 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5530 
    args = getOrdersForCustomer_args()
94 ashish 5531 
    args.read(iprot)
5532 
    iprot.readMessageEnd()
483 rajveer 5533 
    result = getOrdersForCustomer_result()
94 ashish 5534 
    try:
3014 chandransh 5535 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5536 
    except TransactionServiceException, ex:
5537 
      result.ex = ex
483 rajveer 5538 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5539 
    result.write(oprot)
5540 
    oprot.writeMessageEnd()
5541 
    oprot.trans.flush()
5542 
 
483 rajveer 5543 
  def process_createOrder(self, seqid, iprot, oprot):
5544 
    args = createOrder_args()
94 ashish 5545 
    args.read(iprot)
5546 
    iprot.readMessageEnd()
483 rajveer 5547 
    result = createOrder_result()
94 ashish 5548 
    try:
483 rajveer 5549 
      result.success = self._handler.createOrder(args.order)
94 ashish 5550 
    except TransactionServiceException, ex:
5551 
      result.ex = ex
483 rajveer 5552 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5553 
    result.write(oprot)
5554 
    oprot.writeMessageEnd()
5555 
    oprot.trans.flush()
5556 
 
483 rajveer 5557 
  def process_getOrder(self, seqid, iprot, oprot):
5558 
    args = getOrder_args()
94 ashish 5559 
    args.read(iprot)
5560 
    iprot.readMessageEnd()
483 rajveer 5561 
    result = getOrder_result()
94 ashish 5562 
    try:
483 rajveer 5563 
      result.success = self._handler.getOrder(args.id)
94 ashish 5564 
    except TransactionServiceException, ex:
5565 
      result.ex = ex
483 rajveer 5566 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
5570 
 
483 rajveer 5571 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5572 
    args = getLineItemsForOrder_args()
94 ashish 5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
483 rajveer 5575 
    result = getLineItemsForOrder_result()
94 ashish 5576 
    try:
483 rajveer 5577 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5578 
    except TransactionServiceException, ex:
5579 
      result.ex = ex
483 rajveer 5580 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
4999 phani.kuma 5585 
  def process_getOrderList(self, seqid, iprot, oprot):
5586 
    args = getOrderList_args()
5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
5589 
    result = getOrderList_result()
5590 
    result.success = self._handler.getOrderList(args.order_ids)
5591 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
5595 
 
5386 phani.kuma 5596 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
5597 
    args = getOrderListForVendor_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = getOrderListForVendor_result()
5601 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
5602 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
1528 ankur.sing 5607 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5608 
    args = getOrderForCustomer_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = getOrderForCustomer_result()
5612 
    try:
5613 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5614 
    except TransactionServiceException, ex:
5615 
      result.ex = ex
5616 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
5620 
 
3064 chandransh 5621 
  def process_getAlerts(self, seqid, iprot, oprot):
5622 
    args = getAlerts_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = getAlerts_result()
4444 rajveer 5626 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5627 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5628 
    result.write(oprot)
5629 
    oprot.writeMessageEnd()
5630 
    oprot.trans.flush()
5631 
 
4394 rajveer 5632 
  def process_addAlert(self, seqid, iprot, oprot):
5633 
    args = addAlert_args()
3064 chandransh 5634 
    args.read(iprot)
5635 
    iprot.readMessageEnd()
4394 rajveer 5636 
    result = addAlert_result()
4444 rajveer 5637 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5638 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5639 
    result.write(oprot)
5640 
    oprot.writeMessageEnd()
5641 
    oprot.trans.flush()
5642 
 
4444 rajveer 5643 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5644 
    args = markAlertsAsSeen_args()
5645 
    args.read(iprot)
5646 
    iprot.readMessageEnd()
5647 
    result = markAlertsAsSeen_result()
5648 
    self._handler.markAlertsAsSeen(args.warehouseId)
5649 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5650 
    result.write(oprot)
5651 
    oprot.writeMessageEnd()
5652 
    oprot.trans.flush()
5653 
 
3064 chandransh 5654 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5655 
    args = getValidOrderCount_args()
5656 
    args.read(iprot)
5657 
    iprot.readMessageEnd()
5658 
    result = getValidOrderCount_result()
5659 
    result.success = self._handler.getValidOrderCount()
5660 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5661 
    result.write(oprot)
5662 
    oprot.writeMessageEnd()
5663 
    oprot.trans.flush()
5664 
 
5665 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5666 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5667 
    args.read(iprot)
5668 
    iprot.readMessageEnd()
5669 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5670 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5671 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5672 
    result.write(oprot)
5673 
    oprot.writeMessageEnd()
5674 
    oprot.trans.flush()
5675 
 
5676 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5677 
    args = getValidOrdersAmountRange_args()
5678 
    args.read(iprot)
5679 
    iprot.readMessageEnd()
5680 
    result = getValidOrdersAmountRange_result()
5681 
    result.success = self._handler.getValidOrdersAmountRange()
5682 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5683 
    result.write(oprot)
5684 
    oprot.writeMessageEnd()
5685 
    oprot.trans.flush()
5686 
 
5687 
  def process_getValidOrders(self, seqid, iprot, oprot):
5688 
    args = getValidOrders_args()
5689 
    args.read(iprot)
5690 
    iprot.readMessageEnd()
5691 
    result = getValidOrders_result()
5692 
    result.success = self._handler.getValidOrders(args.limit)
5693 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5694 
    result.write(oprot)
5695 
    oprot.writeMessageEnd()
5696 
    oprot.trans.flush()
5697 
 
1220 chandransh 5698 
  def process_batchOrders(self, seqid, iprot, oprot):
5699 
    args = batchOrders_args()
5700 
    args.read(iprot)
5701 
    iprot.readMessageEnd()
5702 
    result = batchOrders_result()
5703 
    try:
5704 
      result.success = self._handler.batchOrders(args.warehouseId)
5705 
    except TransactionServiceException, ex:
5706 
      result.ex = ex
5707 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5708 
    result.write(oprot)
5709 
    oprot.writeMessageEnd()
5710 
    oprot.trans.flush()
5711 
 
1208 chandransh 5712 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5713 
    args = markOrderAsOutOfStock_args()
5714 
    args.read(iprot)
5715 
    iprot.readMessageEnd()
5716 
    result = markOrderAsOutOfStock_result()
5717 
    try:
5718 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5719 
    except TransactionServiceException, ex:
5720 
      result.ex = ex
5721 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5722 
    result.write(oprot)
5723 
    oprot.writeMessageEnd()
5724 
    oprot.trans.flush()
5725 
 
3064 chandransh 5726 
  def process_verifyOrder(self, seqid, iprot, oprot):
5727 
    args = verifyOrder_args()
759 chandransh 5728 
    args.read(iprot)
5729 
    iprot.readMessageEnd()
3064 chandransh 5730 
    result = verifyOrder_result()
759 chandransh 5731 
    try:
3064 chandransh 5732 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5733 
    except TransactionServiceException, ex:
5734 
      result.ex = ex
3064 chandransh 5735 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5736 
    result.write(oprot)
5737 
    oprot.writeMessageEnd()
5738 
    oprot.trans.flush()
5739 
 
3064 chandransh 5740 
  def process_acceptOrder(self, seqid, iprot, oprot):
5741 
    args = acceptOrder_args()
1113 chandransh 5742 
    args.read(iprot)
5743 
    iprot.readMessageEnd()
3064 chandransh 5744 
    result = acceptOrder_result()
1113 chandransh 5745 
    try:
3064 chandransh 5746 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5747 
    except TransactionServiceException, ex:
5748 
      result.ex = ex
3064 chandransh 5749 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5750 
    result.write(oprot)
5751 
    oprot.writeMessageEnd()
5752 
    oprot.trans.flush()
5753 
 
3064 chandransh 5754 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5755 
    args = addBillingDetails_args()
1135 chandransh 5756 
    args.read(iprot)
5757 
    iprot.readMessageEnd()
3064 chandransh 5758 
    result = addBillingDetails_result()
1135 chandransh 5759 
    try:
5110 mandeep.dh 5760 
      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 5761 
    except TransactionServiceException, ex:
5762 
      result.ex = ex
3064 chandransh 5763 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5764 
    result.write(oprot)
5765 
    oprot.writeMessageEnd()
5766 
    oprot.trans.flush()
5767 
 
4579 rajveer 5768 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5769 
    args = addInvoiceNumber_args()
5770 
    args.read(iprot)
5771 
    iprot.readMessageEnd()
5772 
    result = addInvoiceNumber_result()
5773 
    try:
4763 rajveer 5774 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5775 
    except TransactionServiceException, ex:
5776 
      result.ex = ex
5777 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5778 
    result.write(oprot)
5779 
    oprot.writeMessageEnd()
5780 
    oprot.trans.flush()
5781 
 
4410 rajveer 5782 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5783 
    args = markOrdersAsShippedFromWarehouse_args()
5784 
    args.read(iprot)
5785 
    iprot.readMessageEnd()
5786 
    result = markOrdersAsShippedFromWarehouse_result()
5787 
    try:
4789 rajveer 5788 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5789 
    except TransactionServiceException, ex:
5790 
      result.ex = ex
5791 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5792 
    result.write(oprot)
5793 
    oprot.writeMessageEnd()
5794 
    oprot.trans.flush()
5795 
 
3064 chandransh 5796 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5797 
    args = markOrdersAsPickedUp_args()
304 ashish 5798 
    args.read(iprot)
5799 
    iprot.readMessageEnd()
3064 chandransh 5800 
    result = markOrdersAsPickedUp_result()
5801 
    try:
4910 phani.kuma 5802 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5803 
    except TransactionServiceException, ex:
5804 
      result.ex = ex
5805 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5806 
    result.write(oprot)
5807 
    oprot.writeMessageEnd()
5808 
    oprot.trans.flush()
94 ashish 5809 
 
4910 phani.kuma 5810 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5811 
    args = getOrdersNotPickedUp_args()
5812 
    args.read(iprot)
5813 
    iprot.readMessageEnd()
5814 
    result = getOrdersNotPickedUp_result()
5815 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5816 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5817 
    result.write(oprot)
5818 
    oprot.writeMessageEnd()
5819 
    oprot.trans.flush()
5820 
 
3064 chandransh 5821 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5822 
    args = markOrdersAsDelivered_args()
304 ashish 5823 
    args.read(iprot)
5824 
    iprot.readMessageEnd()
3064 chandransh 5825 
    result = markOrdersAsDelivered_result()
5826 
    try:
5827 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5828 
    except TransactionServiceException, ex:
5829 
      result.ex = ex
5830 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5831 
    result.write(oprot)
5832 
    oprot.writeMessageEnd()
5833 
    oprot.trans.flush()
5834 
 
4910 phani.kuma 5835 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5836 
    args = markAsRTOrders_args()
1596 ankur.sing 5837 
    args.read(iprot)
5838 
    iprot.readMessageEnd()
4910 phani.kuma 5839 
    result = markAsRTOrders_result()
3064 chandransh 5840 
    try:
4910 phani.kuma 5841 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5842 
    except TransactionServiceException, ex:
5843 
      result.ex = ex
4910 phani.kuma 5844 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5845 
    result.write(oprot)
5846 
    oprot.writeMessageEnd()
5847 
    oprot.trans.flush()
304 ashish 5848 
 
4910 phani.kuma 5849 
  def process_getRTOrders(self, seqid, iprot, oprot):
5850 
    args = getRTOrders_args()
5851 
    args.read(iprot)
5852 
    iprot.readMessageEnd()
5853 
    result = getRTOrders_result()
5854 
    result.success = self._handler.getRTOrders(args.providerId)
5855 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5856 
    result.write(oprot)
5857 
    oprot.writeMessageEnd()
5858 
    oprot.trans.flush()
5859 
 
3064 chandransh 5860 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5861 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5862 
    args.read(iprot)
5863 
    iprot.readMessageEnd()
3064 chandransh 5864 
    result = updateNonDeliveryReason_result()
5865 
    try:
4910 phani.kuma 5866 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5867 
    except TransactionServiceException, ex:
5868 
      result.ex = ex
5869 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5870 
    result.write(oprot)
5871 
    oprot.writeMessageEnd()
5872 
    oprot.trans.flush()
1596 ankur.sing 5873 
 
4910 phani.kuma 5874 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5875 
    args = getNonDeliveredOrdersbyCourier_args()
5876 
    args.read(iprot)
5877 
    iprot.readMessageEnd()
5878 
    result = getNonDeliveredOrdersbyCourier_result()
5879 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5880 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5881 
    result.write(oprot)
5882 
    oprot.writeMessageEnd()
5883 
    oprot.trans.flush()
5884 
 
5885 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5886 
    args = markOrdersAsLocalConnected_args()
5887 
    args.read(iprot)
5888 
    iprot.readMessageEnd()
5889 
    result = markOrdersAsLocalConnected_result()
5890 
    try:
5891 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5892 
    except TransactionServiceException, ex:
5893 
      result.ex = ex
5894 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5895 
    result.write(oprot)
5896 
    oprot.writeMessageEnd()
5897 
    oprot.trans.flush()
5898 
 
5899 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5900 
    args = getOrdersNotLocalConnected_args()
5901 
    args.read(iprot)
5902 
    iprot.readMessageEnd()
5903 
    result = getOrdersNotLocalConnected_result()
5904 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5905 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5906 
    result.write(oprot)
5907 
    oprot.writeMessageEnd()
5908 
    oprot.trans.flush()
5909 
 
5910 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5911 
    args = markOrdersAsDestinationCityReached_args()
5912 
    args.read(iprot)
5913 
    iprot.readMessageEnd()
5914 
    result = markOrdersAsDestinationCityReached_result()
5915 
    try:
5916 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5917 
    except TransactionServiceException, ex:
5918 
      result.ex = ex
5919 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5920 
    result.write(oprot)
5921 
    oprot.writeMessageEnd()
5922 
    oprot.trans.flush()
5923 
 
5924 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5925 
    args = markOrdersAsFirstDeliveryAttempted_args()
5926 
    args.read(iprot)
5927 
    iprot.readMessageEnd()
5928 
    result = markOrdersAsFirstDeliveryAttempted_result()
5929 
    try:
5930 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5931 
    except TransactionServiceException, ex:
5932 
      result.ex = ex
5933 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5934 
    result.write(oprot)
5935 
    oprot.writeMessageEnd()
5936 
    oprot.trans.flush()
5937 
 
3064 chandransh 5938 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5939 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5940 
    args.read(iprot)
5941 
    iprot.readMessageEnd()
3064 chandransh 5942 
    result = getUndeliveredOrders_result()
5943 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5944 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5945 
    result.write(oprot)
5946 
    oprot.writeMessageEnd()
5947 
    oprot.trans.flush()
5948 
 
4783 phani.kuma 5949 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5950 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5951 
    args.read(iprot)
5952 
    iprot.readMessageEnd()
5953 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5954 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5955 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5956 
    result.write(oprot)
5957 
    oprot.writeMessageEnd()
5958 
    oprot.trans.flush()
5959 
 
2536 chandransh 5960 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5961 
    args = toggleDOAFlag_args()
5962 
    args.read(iprot)
5963 
    iprot.readMessageEnd()
5964 
    result = toggleDOAFlag_result()
5965 
    try:
5966 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5967 
    except TransactionServiceException, ex:
5968 
      result.ex = ex
5969 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
1886 ankur.sing 5973 
 
4712 rajveer 5974 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5975 
    args = markOrderAsDelivered_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = markOrderAsDelivered_result()
5979 
    try:
5980 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5981 
    except TransactionServiceException, ex:
5982 
      result.ex = ex
5983 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5984 
    result.write(oprot)
5985 
    oprot.writeMessageEnd()
5986 
    oprot.trans.flush()
5987 
 
4454 rajveer 5988 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5989 
    args = markOrderDoaRequestReceived_args()
5990 
    args.read(iprot)
5991 
    iprot.readMessageEnd()
5992 
    result = markOrderDoaRequestReceived_result()
5993 
    try:
5994 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5995 
    except TransactionServiceException, ex:
5996 
      result.ex = ex
5997 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5998 
    result.write(oprot)
5999 
    oprot.writeMessageEnd()
6000 
    oprot.trans.flush()
6001 
 
6002 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6003 
    args = markOrderDoaRequestAuthorized_args()
6004 
    args.read(iprot)
6005 
    iprot.readMessageEnd()
6006 
    result = markOrderDoaRequestAuthorized_result()
6007 
    try:
6008 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6009 
    except TransactionServiceException, ex:
6010 
      result.ex = ex
6011 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6012 
    result.write(oprot)
6013 
    oprot.writeMessageEnd()
6014 
    oprot.trans.flush()
6015 
 
4488 rajveer 6016 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6017 
    args = markOrderReturnRequestReceived_args()
6018 
    args.read(iprot)
6019 
    iprot.readMessageEnd()
6020 
    result = markOrderReturnRequestReceived_result()
6021 
    try:
6022 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6023 
    except TransactionServiceException, ex:
6024 
      result.ex = ex
6025 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
6029 
 
6030 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6031 
    args = markOrderReturnRequestAuthorized_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = markOrderReturnRequestAuthorized_result()
6035 
    try:
6036 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6037 
    except TransactionServiceException, ex:
6038 
      result.ex = ex
6039 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
6043 
 
2536 chandransh 6044 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6045 
    args = requestPickupNumber_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = requestPickupNumber_result()
6049 
    try:
4579 rajveer 6050 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6051 
    except TransactionServiceException, ex:
6052 
      result.ex = ex
6053 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6054 
    result.write(oprot)
6055 
    oprot.writeMessageEnd()
6056 
    oprot.trans.flush()
6057 
 
6058 
  def process_authorizePickup(self, seqid, iprot, oprot):
6059 
    args = authorizePickup_args()
6060 
    args.read(iprot)
6061 
    iprot.readMessageEnd()
6062 
    result = authorizePickup_result()
6063 
    try:
4602 rajveer 6064 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6065 
    except TransactionServiceException, ex:
6066 
      result.ex = ex
6067 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6068 
    result.write(oprot)
6069 
    oprot.writeMessageEnd()
6070 
    oprot.trans.flush()
6071 
 
2764 chandransh 6072 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6073 
    args = markDoasAsPickedUp_args()
6074 
    args.read(iprot)
6075 
    iprot.readMessageEnd()
6076 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6077 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6078 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6079 
    result.write(oprot)
6080 
    oprot.writeMessageEnd()
6081 
    oprot.trans.flush()
6082 
 
4910 phani.kuma 6083 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6084 
    args = getDoasNotPickedUp_args()
6085 
    args.read(iprot)
6086 
    iprot.readMessageEnd()
6087 
    result = getDoasNotPickedUp_result()
6088 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6089 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6090 
    result.write(oprot)
6091 
    oprot.writeMessageEnd()
6092 
    oprot.trans.flush()
6093 
 
4741 phani.kuma 6094 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6095 
    args = markReturnOrdersAsPickedUp_args()
6096 
    args.read(iprot)
6097 
    iprot.readMessageEnd()
6098 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6099 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6100 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6101 
    result.write(oprot)
6102 
    oprot.writeMessageEnd()
6103 
    oprot.trans.flush()
6104 
 
4910 phani.kuma 6105 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6106 
    args = getReturnOrdersNotPickedUp_args()
6107 
    args.read(iprot)
6108 
    iprot.readMessageEnd()
6109 
    result = getReturnOrdersNotPickedUp_result()
6110 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6111 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6112 
    result.write(oprot)
6113 
    oprot.writeMessageEnd()
6114 
    oprot.trans.flush()
6115 
 
2616 chandransh 6116 
  def process_receiveReturn(self, seqid, iprot, oprot):
6117 
    args = receiveReturn_args()
2591 chandransh 6118 
    args.read(iprot)
6119 
    iprot.readMessageEnd()
2616 chandransh 6120 
    result = receiveReturn_result()
2591 chandransh 6121 
    try:
4479 rajveer 6122 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6123 
    except TransactionServiceException, ex:
6124 
      result.ex = ex
2616 chandransh 6125 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6126 
    result.write(oprot)
6127 
    oprot.writeMessageEnd()
6128 
    oprot.trans.flush()
2536 chandransh 6129 
 
2591 chandransh 6130 
  def process_validateDoa(self, seqid, iprot, oprot):
6131 
    args = validateDoa_args()
6132 
    args.read(iprot)
6133 
    iprot.readMessageEnd()
6134 
    result = validateDoa_result()
6135 
    try:
6136 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6137 
    except TransactionServiceException, ex:
6138 
      result.ex = ex
6139 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6140 
    result.write(oprot)
6141 
    oprot.writeMessageEnd()
6142 
    oprot.trans.flush()
6143 
 
4495 rajveer 6144 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6145 
    args = validateReturnProduct_args()
6146 
    args.read(iprot)
6147 
    iprot.readMessageEnd()
6148 
    result = validateReturnProduct_result()
6149 
    try:
6150 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6151 
    except TransactionServiceException, ex:
6152 
      result.ex = ex
6153 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6154 
    result.write(oprot)
6155 
    oprot.writeMessageEnd()
6156 
    oprot.trans.flush()
6157 
 
2616 chandransh 6158 
  def process_reshipOrder(self, seqid, iprot, oprot):
6159 
    args = reshipOrder_args()
6160 
    args.read(iprot)
6161 
    iprot.readMessageEnd()
6162 
    result = reshipOrder_result()
6163 
    try:
6164 
      result.success = self._handler.reshipOrder(args.orderId)
6165 
    except TransactionServiceException, ex:
6166 
      result.ex = ex
6167 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6168 
    result.write(oprot)
6169 
    oprot.writeMessageEnd()
6170 
    oprot.trans.flush()
2591 chandransh 6171 
 
2616 chandransh 6172 
  def process_refundOrder(self, seqid, iprot, oprot):
6173 
    args = refundOrder_args()
6174 
    args.read(iprot)
6175 
    iprot.readMessageEnd()
6176 
    result = refundOrder_result()
6177 
    try:
3226 chandransh 6178 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6179 
    except TransactionServiceException, ex:
6180 
      result.ex = ex
6181 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6182 
    result.write(oprot)
6183 
    oprot.writeMessageEnd()
6184 
    oprot.trans.flush()
6185 
 
2690 chandransh 6186 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6187 
    args = getReturnOrders_args()
6188 
    args.read(iprot)
6189 
    iprot.readMessageEnd()
6190 
    result = getReturnOrders_result()
6191 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6192 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6193 
    result.write(oprot)
6194 
    oprot.writeMessageEnd()
6195 
    oprot.trans.flush()
2616 chandransh 6196 
 
2700 chandransh 6197 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6198 
    args = getReturnOrder_args()
6199 
    args.read(iprot)
6200 
    iprot.readMessageEnd()
6201 
    result = getReturnOrder_result()
6202 
    try:
6203 
      result.success = self._handler.getReturnOrder(args.id)
6204 
    except TransactionServiceException, ex:
6205 
      result.ex = ex
6206 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6207 
    result.write(oprot)
6208 
    oprot.writeMessageEnd()
6209 
    oprot.trans.flush()
6210 
 
2690 chandransh 6211 
  def process_processReturn(self, seqid, iprot, oprot):
6212 
    args = processReturn_args()
6213 
    args.read(iprot)
6214 
    iprot.readMessageEnd()
6215 
    result = processReturn_result()
6216 
    try:
6217 
      self._handler.processReturn(args.returnOrderId)
6218 
    except TransactionServiceException, ex:
6219 
      result.ex = ex
6220 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6221 
    result.write(oprot)
6222 
    oprot.writeMessageEnd()
6223 
    oprot.trans.flush()
6224 
 
3451 chandransh 6225 
  def process_updateWeight(self, seqid, iprot, oprot):
6226 
    args = updateWeight_args()
6227 
    args.read(iprot)
6228 
    iprot.readMessageEnd()
6229 
    result = updateWeight_result()
6230 
    try:
6231 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6232 
    except TransactionServiceException, ex:
6233 
      result.ex = ex
6234 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6235 
    result.write(oprot)
6236 
    oprot.writeMessageEnd()
6237 
    oprot.trans.flush()
2819 chandransh 6238 
 
3469 chandransh 6239 
  def process_changeItem(self, seqid, iprot, oprot):
6240 
    args = changeItem_args()
6241 
    args.read(iprot)
6242 
    iprot.readMessageEnd()
6243 
    result = changeItem_result()
6244 
    try:
6245 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6246 
    except TransactionServiceException, ex:
6247 
      result.ex = ex
6248 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6249 
    result.write(oprot)
6250 
    oprot.writeMessageEnd()
6251 
    oprot.trans.flush()
3451 chandransh 6252 
 
3469 chandransh 6253 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6254 
    args = shiftToWarehouse_args()
6255 
    args.read(iprot)
6256 
    iprot.readMessageEnd()
6257 
    result = shiftToWarehouse_result()
6258 
    try:
6259 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6260 
    except TransactionServiceException, ex:
6261 
      result.ex = ex
6262 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6263 
    result.write(oprot)
6264 
    oprot.writeMessageEnd()
6265 
    oprot.trans.flush()
6266 
 
3553 chandransh 6267 
  def process_addDelayReason(self, seqid, iprot, oprot):
6268 
    args = addDelayReason_args()
6269 
    args.read(iprot)
6270 
    iprot.readMessageEnd()
6271 
    result = addDelayReason_result()
6272 
    try:
4647 rajveer 6273 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6274 
    except TransactionServiceException, ex:
6275 
      result.ex = ex
6276 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6277 
    result.write(oprot)
6278 
    oprot.writeMessageEnd()
6279 
    oprot.trans.flush()
3469 chandransh 6280 
 
3956 chandransh 6281 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6282 
    args = reconcileCodCollection_args()
6283 
    args.read(iprot)
6284 
    iprot.readMessageEnd()
6285 
    result = reconcileCodCollection_result()
6286 
    try:
6287 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6288 
    except TransactionServiceException, ex:
6289 
      result.ex = ex
6290 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6291 
    result.write(oprot)
6292 
    oprot.writeMessageEnd()
6293 
    oprot.trans.flush()
3553 chandransh 6294 
 
4008 mandeep.dh 6295 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6296 
    args = getTransactionsRequiringExtraProcessing_args()
6297 
    args.read(iprot)
6298 
    iprot.readMessageEnd()
6299 
    result = getTransactionsRequiringExtraProcessing_result()
6300 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6301 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6302 
    result.write(oprot)
6303 
    oprot.writeMessageEnd()
6304 
    oprot.trans.flush()
3956 chandransh 6305 
 
4008 mandeep.dh 6306 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6307 
    args = markTransactionAsProcessed_args()
6308 
    args.read(iprot)
6309 
    iprot.readMessageEnd()
6310 
    result = markTransactionAsProcessed_result()
6311 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6312 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6313 
    result.write(oprot)
6314 
    oprot.writeMessageEnd()
6315 
    oprot.trans.flush()
6316 
 
4018 chandransh 6317 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6318 
    args = getItemWiseRiskyOrdersCount_args()
6319 
    args.read(iprot)
6320 
    iprot.readMessageEnd()
6321 
    result = getItemWiseRiskyOrdersCount_result()
6322 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6323 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6324 
    result.write(oprot)
6325 
    oprot.writeMessageEnd()
6326 
    oprot.trans.flush()
4008 mandeep.dh 6327 
 
4295 varun.gupt 6328 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6329 
    args = getOrdersForItemIds_args()
6330 
    args.read(iprot)
6331 
    iprot.readMessageEnd()
6332 
    result = getOrdersForItemIds_result()
6333 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6334 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6335 
    result.write(oprot)
6336 
    oprot.writeMessageEnd()
6337 
    oprot.trans.flush()
6338 
 
4247 rajveer 6339 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6340 
    args = markOrderCancellationRequestReceived_args()
6341 
    args.read(iprot)
6342 
    iprot.readMessageEnd()
6343 
    result = markOrderCancellationRequestReceived_result()
6344 
    try:
6345 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6346 
    except TransactionServiceException, ex:
6347 
      result.ex = ex
6348 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6349 
    result.write(oprot)
6350 
    oprot.writeMessageEnd()
6351 
    oprot.trans.flush()
4018 chandransh 6352 
 
4247 rajveer 6353 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6354 
    args = markOrderCancellationRequestConfirmed_args()
6355 
    args.read(iprot)
6356 
    iprot.readMessageEnd()
6357 
    result = markOrderCancellationRequestConfirmed_result()
6358 
    try:
6359 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6360 
    except TransactionServiceException, ex:
6361 
      result.ex = ex
6362 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6363 
    result.write(oprot)
6364 
    oprot.writeMessageEnd()
6365 
    oprot.trans.flush()
6366 
 
6367 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6368 
    args = markOrderCancellationRequestDenied_args()
6369 
    args.read(iprot)
6370 
    iprot.readMessageEnd()
6371 
    result = markOrderCancellationRequestDenied_result()
6372 
    try:
6373 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6374 
    except TransactionServiceException, ex:
6375 
      result.ex = ex
6376 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6377 
    result.write(oprot)
6378 
    oprot.writeMessageEnd()
6379 
    oprot.trans.flush()
6380 
 
4258 rajveer 6381 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6382 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6383 
    args.read(iprot)
6384 
    iprot.readMessageEnd()
4258 rajveer 6385 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6386 
    try:
4258 rajveer 6387 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6388 
    except TransactionServiceException, ex:
6389 
      result.ex = ex
4258 rajveer 6390 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6391 
    result.write(oprot)
6392 
    oprot.writeMessageEnd()
6393 
    oprot.trans.flush()
6394 
 
4259 anupam.sin 6395 
  def process_refundTransaction(self, seqid, iprot, oprot):
6396 
    args = refundTransaction_args()
6397 
    args.read(iprot)
6398 
    iprot.readMessageEnd()
6399 
    result = refundTransaction_result()
6400 
    try:
6401 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6402 
    except TransactionServiceException, ex:
6403 
      result.ex = ex
6404 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6405 
    result.write(oprot)
6406 
    oprot.writeMessageEnd()
6407 
    oprot.trans.flush()
4247 rajveer 6408 
 
4324 mandeep.dh 6409 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6410 
    args = updateShipmentAddress_args()
6411 
    args.read(iprot)
6412 
    iprot.readMessageEnd()
6413 
    result = updateShipmentAddress_result()
6414 
    try:
6415 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6416 
    except TransactionServiceException, ex:
6417 
      result.ex = ex
6418 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6419 
    result.write(oprot)
6420 
    oprot.writeMessageEnd()
6421 
    oprot.trans.flush()
6422 
 
4285 rajveer 6423 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6424 
    args = acceptOrdersForItemId_args()
6425 
    args.read(iprot)
6426 
    iprot.readMessageEnd()
6427 
    result = acceptOrdersForItemId_result()
6428 
    try:
6429 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6430 
    except TransactionServiceException, ex:
6431 
      result.ex = ex
6432 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6433 
    result.write(oprot)
6434 
    oprot.writeMessageEnd()
6435 
    oprot.trans.flush()
4259 anupam.sin 6436 
 
4303 rajveer 6437 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6438 
    args = markOrdersAsPORaised_args()
6439 
    args.read(iprot)
6440 
    iprot.readMessageEnd()
6441 
    result = markOrdersAsPORaised_result()
6442 
    try:
4369 rajveer 6443 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6444 
    except TransactionServiceException, ex:
6445 
      result.ex = ex
6446 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6447 
    result.write(oprot)
6448 
    oprot.writeMessageEnd()
6449 
    oprot.trans.flush()
4285 rajveer 6450 
 
4303 rajveer 6451 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6452 
    args = markOrdersAsReversalInitiated_args()
6453 
    args.read(iprot)
6454 
    iprot.readMessageEnd()
6455 
    result = markOrdersAsReversalInitiated_result()
6456 
    try:
4369 rajveer 6457 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6458 
    except TransactionServiceException, ex:
6459 
      result.ex = ex
6460 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6461 
    result.write(oprot)
6462 
    oprot.writeMessageEnd()
6463 
    oprot.trans.flush()
6464 
 
6465 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6466 
    args = markOrdersAsNotAvailabke_args()
6467 
    args.read(iprot)
6468 
    iprot.readMessageEnd()
6469 
    result = markOrdersAsNotAvailabke_result()
6470 
    try:
4369 rajveer 6471 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6472 
    except TransactionServiceException, ex:
6473 
      result.ex = ex
6474 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6475 
    result.write(oprot)
6476 
    oprot.writeMessageEnd()
6477 
    oprot.trans.flush()
6478 
 
4369 rajveer 6479 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6480 
    args = markOrdersAsTimeout_args()
6481 
    args.read(iprot)
6482 
    iprot.readMessageEnd()
6483 
    result = markOrdersAsTimeout_result()
6484 
    try:
6485 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6486 
    except TransactionServiceException, ex:
6487 
      result.ex = ex
6488 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6489 
    result.write(oprot)
6490 
    oprot.writeMessageEnd()
6491 
    oprot.trans.flush()
4303 rajveer 6492 
 
4662 rajveer 6493 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6494 
    args = markOrderAsLostInTransit_args()
6495 
    args.read(iprot)
6496 
    iprot.readMessageEnd()
6497 
    result = markOrderAsLostInTransit_result()
6498 
    try:
6499 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6500 
    except TransactionServiceException, ex:
6501 
      result.ex = ex
6502 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6503 
    result.write(oprot)
6504 
    oprot.writeMessageEnd()
6505 
    oprot.trans.flush()
6506 
 
4386 anupam.sin 6507 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6508 
    args = getOrderForAwb_args()
6509 
    args.read(iprot)
6510 
    iprot.readMessageEnd()
6511 
    result = getOrderForAwb_result()
6512 
    try:
6513 
      result.success = self._handler.getOrderForAwb(args.awb)
6514 
    except TransactionServiceException, ex:
6515 
      result.ex = ex
6516 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
4369 rajveer 6520 
 
4506 phani.kuma 6521 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6522 
    args = getOrdersForProviderForStatus_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = getOrdersForProviderForStatus_result()
6526 
    try:
4910 phani.kuma 6527 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6528 
    except TransactionServiceException, ex:
6529 
      result.ex = ex
6530 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
4386 anupam.sin 6534 
 
4600 varun.gupt 6535 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6536 
    args = getBilledOrdersForVendor_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = getBilledOrdersForVendor_result()
6540 
    try:
6541 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6542 
    except TransactionServiceException, ex:
6543 
      result.ex = ex
6544 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6545 
    result.write(oprot)
6546 
    oprot.writeMessageEnd()
6547 
    oprot.trans.flush()
4506 phani.kuma 6548 
 
4607 rajveer 6549 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6550 
    args = getSlippedSippingDateOrders_args()
6551 
    args.read(iprot)
6552 
    iprot.readMessageEnd()
6553 
    result = getSlippedSippingDateOrders_result()
6554 
    try:
6555 
      result.success = self._handler.getSlippedSippingDateOrders()
6556 
    except TransactionServiceException, ex:
6557 
      result.ex = ex
6558 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6559 
    result.write(oprot)
6560 
    oprot.writeMessageEnd()
6561 
    oprot.trans.flush()
6562 
 
4709 rajveer 6563 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6564 
    args = getCancelledOrders_args()
6565 
    args.read(iprot)
6566 
    iprot.readMessageEnd()
6567 
    result = getCancelledOrders_result()
6568 
    try:
6569 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6570 
    except TransactionServiceException, ex:
6571 
      result.ex = ex
6572 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6573 
    result.write(oprot)
6574 
    oprot.writeMessageEnd()
6575 
    oprot.trans.flush()
6576 
 
4600 varun.gupt 6577 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6578 
    args = saveBluedartSettlements_args()
6579 
    args.read(iprot)
6580 
    iprot.readMessageEnd()
6581 
    result = saveBluedartSettlements_result()
6582 
    try:
6583 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6584 
    except TransactionServiceException, ex:
6585 
      result.ex = ex
6586 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6587 
    result.write(oprot)
6588 
    oprot.writeMessageEnd()
6589 
    oprot.trans.flush()
6590 
 
6591 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6592 
    args = savePaymentSettlements_args()
6593 
    args.read(iprot)
6594 
    iprot.readMessageEnd()
6595 
    result = savePaymentSettlements_result()
6596 
    try:
4905 varun.gupt 6597 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6598 
    except TransactionServiceException, ex:
6599 
      result.ex = ex
6600 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6601 
    result.write(oprot)
6602 
    oprot.writeMessageEnd()
6603 
    oprot.trans.flush()
6604 
 
6605 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6606 
    args = saveEBSSettlementSummary_args()
6607 
    args.read(iprot)
6608 
    iprot.readMessageEnd()
6609 
    result = saveEBSSettlementSummary_result()
6610 
    try:
6611 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6612 
    except TransactionServiceException, ex:
6613 
      result.ex = ex
6614 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6615 
    result.write(oprot)
6616 
    oprot.writeMessageEnd()
6617 
    oprot.trans.flush()
6618 
 
5386 phani.kuma 6619 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
6620 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 6621 
    args.read(iprot)
6622 
    iprot.readMessageEnd()
5386 phani.kuma 6623 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 6624 
    try:
5386 phani.kuma 6625 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 6626 
    except TransactionServiceException, ex:
6627 
      result.ex = ex
5386 phani.kuma 6628 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 6629 
    result.write(oprot)
6630 
    oprot.writeMessageEnd()
6631 
    oprot.trans.flush()
6632 
 
5386 phani.kuma 6633 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
6634 
    args = getSettlementForCod_args()
6635 
    args.read(iprot)
6636 
    iprot.readMessageEnd()
6637 
    result = getSettlementForCod_result()
6638 
    try:
6639 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
6640 
    except TransactionServiceException, ex:
6641 
      result.ex = ex
6642 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
6643 
    result.write(oprot)
6644 
    oprot.writeMessageEnd()
6645 
    oprot.trans.flush()
6646 
 
4600 varun.gupt 6647 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6648 
    args = getEBSSettlementSummaries_args()
6649 
    args.read(iprot)
6650 
    iprot.readMessageEnd()
6651 
    result = getEBSSettlementSummaries_result()
6652 
    try:
6653 
      result.success = self._handler.getEBSSettlementSummaries()
6654 
    except TransactionServiceException, ex:
6655 
      result.ex = ex
6656 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6657 
    result.write(oprot)
6658 
    oprot.writeMessageEnd()
6659 
    oprot.trans.flush()
6660 
 
6661 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6662 
    args = markEBSSettlementUploaded_args()
6663 
    args.read(iprot)
6664 
    iprot.readMessageEnd()
6665 
    result = markEBSSettlementUploaded_result()
6666 
    try:
6667 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6668 
    except TransactionServiceException, ex:
6669 
      result.ex = ex
6670 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
6675 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6676 
    args = getEBSSettlementDate_args()
6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
6679 
    result = getEBSSettlementDate_result()
6680 
    try:
6681 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6682 
    except TransactionServiceException, ex:
6683 
      result.ex = ex
6684 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6685 
    result.write(oprot)
6686 
    oprot.writeMessageEnd()
6687 
    oprot.trans.flush()
6688 
 
4715 varun.gupt 6689 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6690 
    args = getSettlementsByDate_args()
6691 
    args.read(iprot)
6692 
    iprot.readMessageEnd()
6693 
    result = getSettlementsByDate_result()
6694 
    try:
6695 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6696 
    except TransactionServiceException, ex:
6697 
      result.ex = ex
6698 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6699 
    result.write(oprot)
6700 
    oprot.writeMessageEnd()
6701 
    oprot.trans.flush()
4600 varun.gupt 6702 
 
4715 varun.gupt 6703 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6704 
    args = getReshippedOrderIds_args()
6705 
    args.read(iprot)
6706 
    iprot.readMessageEnd()
6707 
    result = getReshippedOrderIds_result()
6708 
    try:
6709 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6710 
    except TransactionServiceException, ex:
6711 
      result.ex = ex
6712 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6713 
    result.write(oprot)
6714 
    oprot.writeMessageEnd()
6715 
    oprot.trans.flush()
6716 
 
4875 varun.gupt 6717 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6718 
    args = getOrdersWhereVendorNotPaid_args()
6719 
    args.read(iprot)
6720 
    iprot.readMessageEnd()
6721 
    result = getOrdersWhereVendorNotPaid_result()
6722 
    try:
6723 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6724 
    except TransactionServiceException, ex:
6725 
      result.ex = ex
6726 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6727 
    result.write(oprot)
6728 
    oprot.writeMessageEnd()
6729 
    oprot.trans.flush()
4757 mandeep.dh 6730 
 
5031 varun.gupt 6731 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6732 
    args = getStatusDistributionOfOrders_args()
6733 
    args.read(iprot)
6734 
    iprot.readMessageEnd()
6735 
    result = getStatusDistributionOfOrders_result()
6736 
    try:
6737 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6738 
    except TransactionServiceException, ex:
6739 
      result.ex = ex
6740 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6741 
    result.write(oprot)
6742 
    oprot.writeMessageEnd()
6743 
    oprot.trans.flush()
4875 varun.gupt 6744 
 
5067 varun.gupt 6745 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6746 
    args = getOrderIdsForStatus_args()
6747 
    args.read(iprot)
6748 
    iprot.readMessageEnd()
6749 
    result = getOrderIdsForStatus_result()
6750 
    try:
6751 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6752 
    except TransactionServiceException, ex:
6753 
      result.ex = ex
6754 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6755 
    result.write(oprot)
6756 
    oprot.writeMessageEnd()
6757 
    oprot.trans.flush()
5031 varun.gupt 6758 
 
5348 anupam.sin 6759 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6760 
    args = updateCODAgent_args()
6761 
    args.read(iprot)
6762 
    iprot.readMessageEnd()
6763 
    result = updateCODAgent_result()
6764 
    try:
6765 
      self._handler.updateCODAgent(args.agent, args.orderId)
6766 
    except TransactionServiceException, ex:
6767 
      result.ex = ex
6768 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6769 
    result.write(oprot)
6770 
    oprot.writeMessageEnd()
6771 
    oprot.trans.flush()
6772 
 
5099 varun.gupt 6773 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6774 
    args = updateOrderAsPaidToVendor_args()
6775 
    args.read(iprot)
6776 
    iprot.readMessageEnd()
6777 
    result = updateOrderAsPaidToVendor_result()
6778 
    try:
6779 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6780 
    except TransactionServiceException, ex:
6781 
      result.ex = ex
6782 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6783 
    result.write(oprot)
6784 
    oprot.writeMessageEnd()
6785 
    oprot.trans.flush()
5067 varun.gupt 6786 
 
5386 phani.kuma 6787 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
6788 
    args = updateOrderOnlyAsPaidToVendor_args()
6789 
    args.read(iprot)
6790 
    iprot.readMessageEnd()
6791 
    result = updateOrderOnlyAsPaidToVendor_result()
6792 
    try:
6793 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
6794 
    except TransactionServiceException, ex:
6795 
      result.ex = ex
6796 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
6797 
    result.write(oprot)
6798 
    oprot.writeMessageEnd()
6799 
    oprot.trans.flush()
6800 
 
5208 varun.gupt 6801 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6802 
    args = getRefundedOrdersMarkedPaid_args()
6803 
    args.read(iprot)
6804 
    iprot.readMessageEnd()
6805 
    result = getRefundedOrdersMarkedPaid_result()
6806 
    try:
6807 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6808 
    except TransactionServiceException, ex:
6809 
      result.ex = ex
6810 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6811 
    result.write(oprot)
6812 
    oprot.writeMessageEnd()
6813 
    oprot.trans.flush()
5099 varun.gupt 6814 
 
5447 anupam.sin 6815 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
6816 
    args = getAllVerificationAgents_args()
6817 
    args.read(iprot)
6818 
    iprot.readMessageEnd()
6819 
    result = getAllVerificationAgents_result()
6820 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
6821 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
6822 
    result.write(oprot)
6823 
    oprot.writeMessageEnd()
6824 
    oprot.trans.flush()
5208 varun.gupt 6825 
 
5447 anupam.sin 6826 
 
94 ashish 6827 
# HELPER FUNCTIONS AND STRUCTURES
6828 
 
6829 
class createTransaction_args:
6830 
  """
6831 
  Attributes:
6832 
   - transaction
6833 
  """
6834 
 
6835 
  thrift_spec = (
6836 
    None, # 0
6837 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6838 
  )
6839 
 
6840 
  def __init__(self, transaction=None,):
6841 
    self.transaction = transaction
6842 
 
6843 
  def read(self, iprot):
6844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6846 
      return
6847 
    iprot.readStructBegin()
6848 
    while True:
6849 
      (fname, ftype, fid) = iprot.readFieldBegin()
6850 
      if ftype == TType.STOP:
6851 
        break
6852 
      if fid == 1:
6853 
        if ftype == TType.STRUCT:
6854 
          self.transaction = Transaction()
6855 
          self.transaction.read(iprot)
6856 
        else:
6857 
          iprot.skip(ftype)
6858 
      else:
6859 
        iprot.skip(ftype)
6860 
      iprot.readFieldEnd()
6861 
    iprot.readStructEnd()
6862 
 
6863 
  def write(self, oprot):
6864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6866 
      return
6867 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6868 
    if self.transaction is not None:
94 ashish 6869 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6870 
      self.transaction.write(oprot)
6871 
      oprot.writeFieldEnd()
6872 
    oprot.writeFieldStop()
6873 
    oprot.writeStructEnd()
6874 
 
3431 rajveer 6875 
  def validate(self):
6876 
    return
6877 
 
6878 
 
94 ashish 6879 
  def __repr__(self):
6880 
    L = ['%s=%r' % (key, value)
6881 
      for key, value in self.__dict__.iteritems()]
6882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6883 
 
6884 
  def __eq__(self, other):
6885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6886 
 
6887 
  def __ne__(self, other):
6888 
    return not (self == other)
6889 
 
6890 
class createTransaction_result:
6891 
  """
6892 
  Attributes:
132 ashish 6893 
   - success
94 ashish 6894 
   - ex
6895 
  """
6896 
 
6897 
  thrift_spec = (
132 ashish 6898 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6900 
  )
6901 
 
132 ashish 6902 
  def __init__(self, success=None, ex=None,):
6903 
    self.success = success
94 ashish 6904 
    self.ex = ex
6905 
 
6906 
  def read(self, iprot):
6907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6909 
      return
6910 
    iprot.readStructBegin()
6911 
    while True:
6912 
      (fname, ftype, fid) = iprot.readFieldBegin()
6913 
      if ftype == TType.STOP:
6914 
        break
132 ashish 6915 
      if fid == 0:
6916 
        if ftype == TType.I64:
6917 
          self.success = iprot.readI64();
6918 
        else:
6919 
          iprot.skip(ftype)
6920 
      elif fid == 1:
94 ashish 6921 
        if ftype == TType.STRUCT:
6922 
          self.ex = TransactionServiceException()
6923 
          self.ex.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_result')
3431 rajveer 6936 
    if self.success is not None:
132 ashish 6937 
      oprot.writeFieldBegin('success', TType.I64, 0)
6938 
      oprot.writeI64(self.success)
6939 
      oprot.writeFieldEnd()
3431 rajveer 6940 
    if self.ex is not None:
94 ashish 6941 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6942 
      self.ex.write(oprot)
6943 
      oprot.writeFieldEnd()
6944 
    oprot.writeFieldStop()
6945 
    oprot.writeStructEnd()
6946 
 
3431 rajveer 6947 
  def validate(self):
6948 
    return
6949 
 
6950 
 
94 ashish 6951 
  def __repr__(self):
6952 
    L = ['%s=%r' % (key, value)
6953 
      for key, value in self.__dict__.iteritems()]
6954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6955 
 
6956 
  def __eq__(self, other):
6957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6958 
 
6959 
  def __ne__(self, other):
6960 
    return not (self == other)
6961 
 
6962 
class getTransaction_args:
6963 
  """
6964 
  Attributes:
6965 
   - id
6966 
  """
6967 
 
6968 
  thrift_spec = (
6969 
    None, # 0
6970 
    (1, TType.I64, 'id', None, None, ), # 1
6971 
  )
6972 
 
6973 
  def __init__(self, id=None,):
6974 
    self.id = id
6975 
 
6976 
  def read(self, iprot):
6977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6979 
      return
6980 
    iprot.readStructBegin()
6981 
    while True:
6982 
      (fname, ftype, fid) = iprot.readFieldBegin()
6983 
      if ftype == TType.STOP:
6984 
        break
6985 
      if fid == 1:
6986 
        if ftype == TType.I64:
6987 
          self.id = iprot.readI64();
6988 
        else:
6989 
          iprot.skip(ftype)
6990 
      else:
6991 
        iprot.skip(ftype)
6992 
      iprot.readFieldEnd()
6993 
    iprot.readStructEnd()
6994 
 
6995 
  def write(self, oprot):
6996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6998 
      return
6999 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7000 
    if self.id is not None:
94 ashish 7001 
      oprot.writeFieldBegin('id', TType.I64, 1)
7002 
      oprot.writeI64(self.id)
7003 
      oprot.writeFieldEnd()
7004 
    oprot.writeFieldStop()
7005 
    oprot.writeStructEnd()
7006 
 
3431 rajveer 7007 
  def validate(self):
7008 
    return
7009 
 
7010 
 
94 ashish 7011 
  def __repr__(self):
7012 
    L = ['%s=%r' % (key, value)
7013 
      for key, value in self.__dict__.iteritems()]
7014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7015 
 
7016 
  def __eq__(self, other):
7017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7018 
 
7019 
  def __ne__(self, other):
7020 
    return not (self == other)
7021 
 
7022 
class getTransaction_result:
7023 
  """
7024 
  Attributes:
7025 
   - success
7026 
   - ex
7027 
  """
7028 
 
7029 
  thrift_spec = (
7030 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7032 
  )
7033 
 
7034 
  def __init__(self, success=None, ex=None,):
7035 
    self.success = success
7036 
    self.ex = ex
7037 
 
7038 
  def read(self, iprot):
7039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7041 
      return
7042 
    iprot.readStructBegin()
7043 
    while True:
7044 
      (fname, ftype, fid) = iprot.readFieldBegin()
7045 
      if ftype == TType.STOP:
7046 
        break
7047 
      if fid == 0:
7048 
        if ftype == TType.STRUCT:
7049 
          self.success = Transaction()
7050 
          self.success.read(iprot)
7051 
        else:
7052 
          iprot.skip(ftype)
7053 
      elif fid == 1:
7054 
        if ftype == TType.STRUCT:
7055 
          self.ex = TransactionServiceException()
7056 
          self.ex.read(iprot)
7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      else:
7060 
        iprot.skip(ftype)
7061 
      iprot.readFieldEnd()
7062 
    iprot.readStructEnd()
7063 
 
7064 
  def write(self, oprot):
7065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7067 
      return
7068 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7069 
    if self.success is not None:
94 ashish 7070 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7071 
      self.success.write(oprot)
7072 
      oprot.writeFieldEnd()
3431 rajveer 7073 
    if self.ex is not None:
94 ashish 7074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7075 
      self.ex.write(oprot)
7076 
      oprot.writeFieldEnd()
7077 
    oprot.writeFieldStop()
7078 
    oprot.writeStructEnd()
7079 
 
3431 rajveer 7080 
  def validate(self):
7081 
    return
7082 
 
7083 
 
94 ashish 7084 
  def __repr__(self):
7085 
    L = ['%s=%r' % (key, value)
7086 
      for key, value in self.__dict__.iteritems()]
7087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7088 
 
7089 
  def __eq__(self, other):
7090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7091 
 
7092 
  def __ne__(self, other):
7093 
    return not (self == other)
7094 
 
7095 
class getTransactionsForCustomer_args:
7096 
  """
7097 
  Attributes:
7098 
   - customerId
7099 
   - from_date
7100 
   - to_date
7101 
   - status
7102 
  """
7103 
 
7104 
  thrift_spec = (
7105 
    None, # 0
7106 
    (1, TType.I64, 'customerId', None, None, ), # 1
7107 
    (2, TType.I64, 'from_date', None, None, ), # 2
7108 
    (3, TType.I64, 'to_date', None, None, ), # 3
7109 
    (4, TType.I32, 'status', None, None, ), # 4
7110 
  )
7111 
 
7112 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7113 
    self.customerId = customerId
7114 
    self.from_date = from_date
7115 
    self.to_date = to_date
7116 
    self.status = status
7117 
 
7118 
  def read(self, iprot):
7119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7121 
      return
7122 
    iprot.readStructBegin()
7123 
    while True:
7124 
      (fname, ftype, fid) = iprot.readFieldBegin()
7125 
      if ftype == TType.STOP:
7126 
        break
7127 
      if fid == 1:
7128 
        if ftype == TType.I64:
7129 
          self.customerId = iprot.readI64();
7130 
        else:
7131 
          iprot.skip(ftype)
7132 
      elif fid == 2:
7133 
        if ftype == TType.I64:
7134 
          self.from_date = iprot.readI64();
7135 
        else:
7136 
          iprot.skip(ftype)
7137 
      elif fid == 3:
7138 
        if ftype == TType.I64:
7139 
          self.to_date = iprot.readI64();
7140 
        else:
7141 
          iprot.skip(ftype)
7142 
      elif fid == 4:
7143 
        if ftype == TType.I32:
7144 
          self.status = iprot.readI32();
7145 
        else:
7146 
          iprot.skip(ftype)
7147 
      else:
7148 
        iprot.skip(ftype)
7149 
      iprot.readFieldEnd()
7150 
    iprot.readStructEnd()
7151 
 
7152 
  def write(self, oprot):
7153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7155 
      return
7156 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7157 
    if self.customerId is not None:
94 ashish 7158 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7159 
      oprot.writeI64(self.customerId)
7160 
      oprot.writeFieldEnd()
3431 rajveer 7161 
    if self.from_date is not None:
94 ashish 7162 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7163 
      oprot.writeI64(self.from_date)
7164 
      oprot.writeFieldEnd()
3431 rajveer 7165 
    if self.to_date is not None:
94 ashish 7166 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7167 
      oprot.writeI64(self.to_date)
7168 
      oprot.writeFieldEnd()
3431 rajveer 7169 
    if self.status is not None:
94 ashish 7170 
      oprot.writeFieldBegin('status', TType.I32, 4)
7171 
      oprot.writeI32(self.status)
7172 
      oprot.writeFieldEnd()
7173 
    oprot.writeFieldStop()
7174 
    oprot.writeStructEnd()
7175 
 
3431 rajveer 7176 
  def validate(self):
7177 
    return
7178 
 
7179 
 
94 ashish 7180 
  def __repr__(self):
7181 
    L = ['%s=%r' % (key, value)
7182 
      for key, value in self.__dict__.iteritems()]
7183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7184 
 
7185 
  def __eq__(self, other):
7186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7187 
 
7188 
  def __ne__(self, other):
7189 
    return not (self == other)
7190 
 
7191 
class getTransactionsForCustomer_result:
7192 
  """
7193 
  Attributes:
7194 
   - success
7195 
   - ex
7196 
  """
7197 
 
7198 
  thrift_spec = (
7199 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7200 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7201 
  )
7202 
 
7203 
  def __init__(self, success=None, ex=None,):
7204 
    self.success = success
7205 
    self.ex = ex
7206 
 
7207 
  def read(self, iprot):
7208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7210 
      return
7211 
    iprot.readStructBegin()
7212 
    while True:
7213 
      (fname, ftype, fid) = iprot.readFieldBegin()
7214 
      if ftype == TType.STOP:
7215 
        break
7216 
      if fid == 0:
7217 
        if ftype == TType.LIST:
7218 
          self.success = []
5031 varun.gupt 7219 
          (_etype66, _size63) = iprot.readListBegin()
7220 
          for _i67 in xrange(_size63):
7221 
            _elem68 = Transaction()
7222 
            _elem68.read(iprot)
7223 
            self.success.append(_elem68)
94 ashish 7224 
          iprot.readListEnd()
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      elif fid == 1:
7228 
        if ftype == TType.STRUCT:
7229 
          self.ex = TransactionServiceException()
7230 
          self.ex.read(iprot)
7231 
        else:
7232 
          iprot.skip(ftype)
7233 
      else:
7234 
        iprot.skip(ftype)
7235 
      iprot.readFieldEnd()
7236 
    iprot.readStructEnd()
7237 
 
7238 
  def write(self, oprot):
7239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7241 
      return
7242 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7243 
    if self.success is not None:
94 ashish 7244 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7245 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7246 
      for iter69 in self.success:
7247 
        iter69.write(oprot)
94 ashish 7248 
      oprot.writeListEnd()
7249 
      oprot.writeFieldEnd()
3431 rajveer 7250 
    if self.ex is not None:
94 ashish 7251 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7252 
      self.ex.write(oprot)
7253 
      oprot.writeFieldEnd()
7254 
    oprot.writeFieldStop()
7255 
    oprot.writeStructEnd()
7256 
 
3431 rajveer 7257 
  def validate(self):
7258 
    return
7259 
 
7260 
 
94 ashish 7261 
  def __repr__(self):
7262 
    L = ['%s=%r' % (key, value)
7263 
      for key, value in self.__dict__.iteritems()]
7264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7265 
 
7266 
  def __eq__(self, other):
7267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7268 
 
7269 
  def __ne__(self, other):
7270 
    return not (self == other)
7271 
 
132 ashish 7272 
class getTransactionsForShoppingCartId_args:
7273 
  """
7274 
  Attributes:
7275 
   - shoppingCartId
7276 
  """
7277 
 
7278 
  thrift_spec = (
7279 
    None, # 0
7280 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7281 
  )
7282 
 
7283 
  def __init__(self, shoppingCartId=None,):
7284 
    self.shoppingCartId = shoppingCartId
7285 
 
7286 
  def read(self, iprot):
7287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7289 
      return
7290 
    iprot.readStructBegin()
7291 
    while True:
7292 
      (fname, ftype, fid) = iprot.readFieldBegin()
7293 
      if ftype == TType.STOP:
7294 
        break
7295 
      if fid == 1:
7296 
        if ftype == TType.I64:
7297 
          self.shoppingCartId = iprot.readI64();
7298 
        else:
7299 
          iprot.skip(ftype)
7300 
      else:
7301 
        iprot.skip(ftype)
7302 
      iprot.readFieldEnd()
7303 
    iprot.readStructEnd()
7304 
 
7305 
  def write(self, oprot):
7306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7308 
      return
7309 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7310 
    if self.shoppingCartId is not None:
132 ashish 7311 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7312 
      oprot.writeI64(self.shoppingCartId)
7313 
      oprot.writeFieldEnd()
7314 
    oprot.writeFieldStop()
7315 
    oprot.writeStructEnd()
7316 
 
3431 rajveer 7317 
  def validate(self):
7318 
    return
7319 
 
7320 
 
132 ashish 7321 
  def __repr__(self):
7322 
    L = ['%s=%r' % (key, value)
7323 
      for key, value in self.__dict__.iteritems()]
7324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7325 
 
7326 
  def __eq__(self, other):
7327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7328 
 
7329 
  def __ne__(self, other):
7330 
    return not (self == other)
7331 
 
7332 
class getTransactionsForShoppingCartId_result:
7333 
  """
7334 
  Attributes:
7335 
   - success
7336 
   - ex
7337 
  """
7338 
 
7339 
  thrift_spec = (
7340 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7342 
  )
7343 
 
7344 
  def __init__(self, success=None, ex=None,):
7345 
    self.success = success
7346 
    self.ex = ex
7347 
 
7348 
  def read(self, iprot):
7349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7351 
      return
7352 
    iprot.readStructBegin()
7353 
    while True:
7354 
      (fname, ftype, fid) = iprot.readFieldBegin()
7355 
      if ftype == TType.STOP:
7356 
        break
7357 
      if fid == 0:
7358 
        if ftype == TType.LIST:
7359 
          self.success = []
5031 varun.gupt 7360 
          (_etype73, _size70) = iprot.readListBegin()
7361 
          for _i74 in xrange(_size70):
7362 
            _elem75 = Transaction()
7363 
            _elem75.read(iprot)
7364 
            self.success.append(_elem75)
132 ashish 7365 
          iprot.readListEnd()
7366 
        else:
7367 
          iprot.skip(ftype)
7368 
      elif fid == 1:
7369 
        if ftype == TType.STRUCT:
7370 
          self.ex = TransactionServiceException()
7371 
          self.ex.read(iprot)
7372 
        else:
7373 
          iprot.skip(ftype)
7374 
      else:
7375 
        iprot.skip(ftype)
7376 
      iprot.readFieldEnd()
7377 
    iprot.readStructEnd()
7378 
 
7379 
  def write(self, oprot):
7380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7382 
      return
7383 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7384 
    if self.success is not None:
132 ashish 7385 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7386 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7387 
      for iter76 in self.success:
7388 
        iter76.write(oprot)
132 ashish 7389 
      oprot.writeListEnd()
7390 
      oprot.writeFieldEnd()
3431 rajveer 7391 
    if self.ex is not None:
132 ashish 7392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7393 
      self.ex.write(oprot)
7394 
      oprot.writeFieldEnd()
7395 
    oprot.writeFieldStop()
7396 
    oprot.writeStructEnd()
7397 
 
3431 rajveer 7398 
  def validate(self):
7399 
    return
7400 
 
7401 
 
132 ashish 7402 
  def __repr__(self):
7403 
    L = ['%s=%r' % (key, value)
7404 
      for key, value in self.__dict__.iteritems()]
7405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7406 
 
7407 
  def __eq__(self, other):
7408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7409 
 
7410 
  def __ne__(self, other):
7411 
    return not (self == other)
7412 
 
94 ashish 7413 
class getTransactionStatus_args:
7414 
  """
7415 
  Attributes:
7416 
   - transactionId
7417 
  """
7418 
 
7419 
  thrift_spec = (
7420 
    None, # 0
7421 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7422 
  )
7423 
 
7424 
  def __init__(self, transactionId=None,):
7425 
    self.transactionId = transactionId
7426 
 
7427 
  def read(self, iprot):
7428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7430 
      return
7431 
    iprot.readStructBegin()
7432 
    while True:
7433 
      (fname, ftype, fid) = iprot.readFieldBegin()
7434 
      if ftype == TType.STOP:
7435 
        break
7436 
      if fid == 1:
7437 
        if ftype == TType.I64:
7438 
          self.transactionId = iprot.readI64();
7439 
        else:
7440 
          iprot.skip(ftype)
7441 
      else:
7442 
        iprot.skip(ftype)
7443 
      iprot.readFieldEnd()
7444 
    iprot.readStructEnd()
7445 
 
7446 
  def write(self, oprot):
7447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7449 
      return
7450 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7451 
    if self.transactionId is not None:
94 ashish 7452 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7453 
      oprot.writeI64(self.transactionId)
7454 
      oprot.writeFieldEnd()
7455 
    oprot.writeFieldStop()
7456 
    oprot.writeStructEnd()
7457 
 
3431 rajveer 7458 
  def validate(self):
7459 
    return
7460 
 
7461 
 
94 ashish 7462 
  def __repr__(self):
7463 
    L = ['%s=%r' % (key, value)
7464 
      for key, value in self.__dict__.iteritems()]
7465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7466 
 
7467 
  def __eq__(self, other):
7468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7469 
 
7470 
  def __ne__(self, other):
7471 
    return not (self == other)
7472 
 
7473 
class getTransactionStatus_result:
7474 
  """
7475 
  Attributes:
7476 
   - success
7477 
   - ex
7478 
  """
7479 
 
7480 
  thrift_spec = (
7481 
    (0, TType.I32, 'success', None, None, ), # 0
7482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7483 
  )
7484 
 
7485 
  def __init__(self, success=None, ex=None,):
7486 
    self.success = success
7487 
    self.ex = ex
7488 
 
7489 
  def read(self, iprot):
7490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7492 
      return
7493 
    iprot.readStructBegin()
7494 
    while True:
7495 
      (fname, ftype, fid) = iprot.readFieldBegin()
7496 
      if ftype == TType.STOP:
7497 
        break
7498 
      if fid == 0:
7499 
        if ftype == TType.I32:
7500 
          self.success = iprot.readI32();
7501 
        else:
7502 
          iprot.skip(ftype)
7503 
      elif fid == 1:
7504 
        if ftype == TType.STRUCT:
7505 
          self.ex = TransactionServiceException()
7506 
          self.ex.read(iprot)
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_result')
3431 rajveer 7519 
    if self.success is not None:
94 ashish 7520 
      oprot.writeFieldBegin('success', TType.I32, 0)
7521 
      oprot.writeI32(self.success)
7522 
      oprot.writeFieldEnd()
3431 rajveer 7523 
    if self.ex is not None:
94 ashish 7524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7525 
      self.ex.write(oprot)
7526 
      oprot.writeFieldEnd()
7527 
    oprot.writeFieldStop()
7528 
    oprot.writeStructEnd()
7529 
 
3431 rajveer 7530 
  def validate(self):
7531 
    return
7532 
 
7533 
 
94 ashish 7534 
  def __repr__(self):
7535 
    L = ['%s=%r' % (key, value)
7536 
      for key, value in self.__dict__.iteritems()]
7537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7538 
 
7539 
  def __eq__(self, other):
7540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7541 
 
7542 
  def __ne__(self, other):
7543 
    return not (self == other)
7544 
 
7545 
class changeTransactionStatus_args:
7546 
  """
7547 
  Attributes:
7548 
   - transactionId
7549 
   - status
7550 
   - description
5387 rajveer 7551 
   - selfPickup
94 ashish 7552 
  """
7553 
 
7554 
  thrift_spec = (
7555 
    None, # 0
7556 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7557 
    (2, TType.I32, 'status', None, None, ), # 2
7558 
    (3, TType.STRING, 'description', None, None, ), # 3
5387 rajveer 7559 
    (4, TType.BOOL, 'selfPickup', None, None, ), # 4
94 ashish 7560 
  )
7561 
 
5387 rajveer 7562 
  def __init__(self, transactionId=None, status=None, description=None, selfPickup=None,):
94 ashish 7563 
    self.transactionId = transactionId
7564 
    self.status = status
7565 
    self.description = description
5387 rajveer 7566 
    self.selfPickup = selfPickup
94 ashish 7567 
 
7568 
  def read(self, iprot):
7569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7571 
      return
7572 
    iprot.readStructBegin()
7573 
    while True:
7574 
      (fname, ftype, fid) = iprot.readFieldBegin()
7575 
      if ftype == TType.STOP:
7576 
        break
7577 
      if fid == 1:
7578 
        if ftype == TType.I64:
7579 
          self.transactionId = iprot.readI64();
7580 
        else:
7581 
          iprot.skip(ftype)
7582 
      elif fid == 2:
7583 
        if ftype == TType.I32:
7584 
          self.status = iprot.readI32();
7585 
        else:
7586 
          iprot.skip(ftype)
7587 
      elif fid == 3:
7588 
        if ftype == TType.STRING:
7589 
          self.description = iprot.readString();
7590 
        else:
7591 
          iprot.skip(ftype)
5387 rajveer 7592 
      elif fid == 4:
7593 
        if ftype == TType.BOOL:
7594 
          self.selfPickup = iprot.readBool();
7595 
        else:
7596 
          iprot.skip(ftype)
94 ashish 7597 
      else:
7598 
        iprot.skip(ftype)
7599 
      iprot.readFieldEnd()
7600 
    iprot.readStructEnd()
7601 
 
7602 
  def write(self, oprot):
7603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7605 
      return
7606 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7607 
    if self.transactionId is not None:
94 ashish 7608 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7609 
      oprot.writeI64(self.transactionId)
7610 
      oprot.writeFieldEnd()
3431 rajveer 7611 
    if self.status is not None:
94 ashish 7612 
      oprot.writeFieldBegin('status', TType.I32, 2)
7613 
      oprot.writeI32(self.status)
7614 
      oprot.writeFieldEnd()
3431 rajveer 7615 
    if self.description is not None:
94 ashish 7616 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7617 
      oprot.writeString(self.description)
7618 
      oprot.writeFieldEnd()
5387 rajveer 7619 
    if self.selfPickup is not None:
7620 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 4)
7621 
      oprot.writeBool(self.selfPickup)
7622 
      oprot.writeFieldEnd()
94 ashish 7623 
    oprot.writeFieldStop()
7624 
    oprot.writeStructEnd()
7625 
 
3431 rajveer 7626 
  def validate(self):
7627 
    return
7628 
 
7629 
 
94 ashish 7630 
  def __repr__(self):
7631 
    L = ['%s=%r' % (key, value)
7632 
      for key, value in self.__dict__.iteritems()]
7633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7634 
 
7635 
  def __eq__(self, other):
7636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7637 
 
7638 
  def __ne__(self, other):
7639 
    return not (self == other)
7640 
 
7641 
class changeTransactionStatus_result:
7642 
  """
7643 
  Attributes:
7644 
   - success
7645 
   - ex
7646 
  """
7647 
 
7648 
  thrift_spec = (
7649 
    (0, TType.BOOL, 'success', None, None, ), # 0
7650 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7651 
  )
7652 
 
7653 
  def __init__(self, success=None, ex=None,):
7654 
    self.success = success
7655 
    self.ex = ex
7656 
 
7657 
  def read(self, iprot):
7658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7660 
      return
7661 
    iprot.readStructBegin()
7662 
    while True:
7663 
      (fname, ftype, fid) = iprot.readFieldBegin()
7664 
      if ftype == TType.STOP:
7665 
        break
7666 
      if fid == 0:
7667 
        if ftype == TType.BOOL:
7668 
          self.success = iprot.readBool();
7669 
        else:
7670 
          iprot.skip(ftype)
7671 
      elif fid == 1:
7672 
        if ftype == TType.STRUCT:
7673 
          self.ex = TransactionServiceException()
7674 
          self.ex.read(iprot)
7675 
        else:
7676 
          iprot.skip(ftype)
7677 
      else:
7678 
        iprot.skip(ftype)
7679 
      iprot.readFieldEnd()
7680 
    iprot.readStructEnd()
7681 
 
7682 
  def write(self, oprot):
7683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7685 
      return
7686 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7687 
    if self.success is not None:
94 ashish 7688 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7689 
      oprot.writeBool(self.success)
7690 
      oprot.writeFieldEnd()
3431 rajveer 7691 
    if self.ex is not None:
94 ashish 7692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7693 
      self.ex.write(oprot)
7694 
      oprot.writeFieldEnd()
7695 
    oprot.writeFieldStop()
7696 
    oprot.writeStructEnd()
7697 
 
3431 rajveer 7698 
  def validate(self):
7699 
    return
7700 
 
7701 
 
94 ashish 7702 
  def __repr__(self):
7703 
    L = ['%s=%r' % (key, value)
7704 
      for key, value in self.__dict__.iteritems()]
7705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7706 
 
7707 
  def __eq__(self, other):
7708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7709 
 
7710 
  def __ne__(self, other):
7711 
    return not (self == other)
7712 
 
1398 varun.gupt 7713 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7714 
  """
7715 
  Attributes:
7716 
   - transactionId
7717 
  """
7718 
 
7719 
  thrift_spec = (
7720 
    None, # 0
7721 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7722 
  )
7723 
 
7724 
  def __init__(self, transactionId=None,):
7725 
    self.transactionId = transactionId
7726 
 
7727 
  def read(self, iprot):
7728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7730 
      return
7731 
    iprot.readStructBegin()
7732 
    while True:
7733 
      (fname, ftype, fid) = iprot.readFieldBegin()
7734 
      if ftype == TType.STOP:
7735 
        break
7736 
      if fid == 1:
7737 
        if ftype == TType.I64:
7738 
          self.transactionId = iprot.readI64();
7739 
        else:
7740 
          iprot.skip(ftype)
7741 
      else:
7742 
        iprot.skip(ftype)
7743 
      iprot.readFieldEnd()
7744 
    iprot.readStructEnd()
7745 
 
7746 
  def write(self, oprot):
7747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7749 
      return
1398 varun.gupt 7750 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7751 
    if self.transactionId is not None:
1382 varun.gupt 7752 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7753 
      oprot.writeI64(self.transactionId)
7754 
      oprot.writeFieldEnd()
7755 
    oprot.writeFieldStop()
7756 
    oprot.writeStructEnd()
7757 
 
3431 rajveer 7758 
  def validate(self):
7759 
    return
7760 
 
7761 
 
1382 varun.gupt 7762 
  def __repr__(self):
7763 
    L = ['%s=%r' % (key, value)
7764 
      for key, value in self.__dict__.iteritems()]
7765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7766 
 
7767 
  def __eq__(self, other):
7768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7769 
 
7770 
  def __ne__(self, other):
7771 
    return not (self == other)
7772 
 
1398 varun.gupt 7773 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7774 
  """
7775 
  Attributes:
7776 
   - success
7777 
   - ex
7778 
  """
7779 
 
7780 
  thrift_spec = (
7781 
    (0, TType.BOOL, 'success', None, None, ), # 0
7782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7783 
  )
7784 
 
7785 
  def __init__(self, success=None, ex=None,):
7786 
    self.success = success
7787 
    self.ex = ex
7788 
 
7789 
  def read(self, iprot):
7790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7792 
      return
7793 
    iprot.readStructBegin()
7794 
    while True:
7795 
      (fname, ftype, fid) = iprot.readFieldBegin()
7796 
      if ftype == TType.STOP:
7797 
        break
7798 
      if fid == 0:
7799 
        if ftype == TType.BOOL:
7800 
          self.success = iprot.readBool();
7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      elif fid == 1:
7804 
        if ftype == TType.STRUCT:
7805 
          self.ex = TransactionServiceException()
7806 
          self.ex.read(iprot)
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_result')
3431 rajveer 7819 
    if self.success is not None:
1382 varun.gupt 7820 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7821 
      oprot.writeBool(self.success)
7822 
      oprot.writeFieldEnd()
3431 rajveer 7823 
    if self.ex is not None:
1382 varun.gupt 7824 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7825 
      self.ex.write(oprot)
7826 
      oprot.writeFieldEnd()
7827 
    oprot.writeFieldStop()
7828 
    oprot.writeStructEnd()
7829 
 
3431 rajveer 7830 
  def validate(self):
7831 
    return
7832 
 
7833 
 
1382 varun.gupt 7834 
  def __repr__(self):
7835 
    L = ['%s=%r' % (key, value)
7836 
      for key, value in self.__dict__.iteritems()]
7837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7838 
 
7839 
  def __eq__(self, other):
7840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7841 
 
7842 
  def __ne__(self, other):
7843 
    return not (self == other)
7844 
 
483 rajveer 7845 
class getAllOrders_args:
94 ashish 7846 
  """
7847 
  Attributes:
4801 anupam.sin 7848 
   - statuses
483 rajveer 7849 
   - from_date
7850 
   - to_date
7851 
   - warehouse_id
94 ashish 7852 
  """
7853 
 
7854 
  thrift_spec = (
7855 
    None, # 0
4801 anupam.sin 7856 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7857 
    (2, TType.I64, 'from_date', None, None, ), # 2
7858 
    (3, TType.I64, 'to_date', None, None, ), # 3
7859 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7860 
  )
7861 
 
4801 anupam.sin 7862 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7863 
    self.statuses = statuses
483 rajveer 7864 
    self.from_date = from_date
7865 
    self.to_date = to_date
7866 
    self.warehouse_id = warehouse_id
94 ashish 7867 
 
7868 
  def read(self, iprot):
7869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7871 
      return
7872 
    iprot.readStructBegin()
7873 
    while True:
7874 
      (fname, ftype, fid) = iprot.readFieldBegin()
7875 
      if ftype == TType.STOP:
7876 
        break
7877 
      if fid == 1:
4801 anupam.sin 7878 
        if ftype == TType.LIST:
7879 
          self.statuses = []
5031 varun.gupt 7880 
          (_etype80, _size77) = iprot.readListBegin()
7881 
          for _i81 in xrange(_size77):
7882 
            _elem82 = iprot.readI32();
7883 
            self.statuses.append(_elem82)
4801 anupam.sin 7884 
          iprot.readListEnd()
94 ashish 7885 
        else:
7886 
          iprot.skip(ftype)
483 rajveer 7887 
      elif fid == 2:
7888 
        if ftype == TType.I64:
7889 
          self.from_date = iprot.readI64();
94 ashish 7890 
        else:
7891 
          iprot.skip(ftype)
483 rajveer 7892 
      elif fid == 3:
7893 
        if ftype == TType.I64:
7894 
          self.to_date = iprot.readI64();
94 ashish 7895 
        else:
7896 
          iprot.skip(ftype)
483 rajveer 7897 
      elif fid == 4:
94 ashish 7898 
        if ftype == TType.I64:
483 rajveer 7899 
          self.warehouse_id = iprot.readI64();
94 ashish 7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      else:
7903 
        iprot.skip(ftype)
7904 
      iprot.readFieldEnd()
7905 
    iprot.readStructEnd()
7906 
 
7907 
  def write(self, oprot):
7908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7910 
      return
483 rajveer 7911 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7912 
    if self.statuses is not None:
7913 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7914 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7915 
      for iter83 in self.statuses:
7916 
        oprot.writeI32(iter83)
4801 anupam.sin 7917 
      oprot.writeListEnd()
94 ashish 7918 
      oprot.writeFieldEnd()
3431 rajveer 7919 
    if self.from_date is not None:
483 rajveer 7920 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7921 
      oprot.writeI64(self.from_date)
94 ashish 7922 
      oprot.writeFieldEnd()
3431 rajveer 7923 
    if self.to_date is not None:
483 rajveer 7924 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7925 
      oprot.writeI64(self.to_date)
94 ashish 7926 
      oprot.writeFieldEnd()
3431 rajveer 7927 
    if self.warehouse_id is not None:
483 rajveer 7928 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7929 
      oprot.writeI64(self.warehouse_id)
94 ashish 7930 
      oprot.writeFieldEnd()
7931 
    oprot.writeFieldStop()
7932 
    oprot.writeStructEnd()
7933 
 
3431 rajveer 7934 
  def validate(self):
7935 
    return
7936 
 
7937 
 
94 ashish 7938 
  def __repr__(self):
7939 
    L = ['%s=%r' % (key, value)
7940 
      for key, value in self.__dict__.iteritems()]
7941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7942 
 
7943 
  def __eq__(self, other):
7944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7945 
 
7946 
  def __ne__(self, other):
7947 
    return not (self == other)
7948 
 
483 rajveer 7949 
class getAllOrders_result:
94 ashish 7950 
  """
7951 
  Attributes:
7952 
   - success
7953 
   - ex
7954 
  """
7955 
 
7956 
  thrift_spec = (
483 rajveer 7957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7959 
  )
7960 
 
7961 
  def __init__(self, success=None, ex=None,):
7962 
    self.success = success
7963 
    self.ex = ex
7964 
 
7965 
  def read(self, iprot):
7966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7968 
      return
7969 
    iprot.readStructBegin()
7970 
    while True:
7971 
      (fname, ftype, fid) = iprot.readFieldBegin()
7972 
      if ftype == TType.STOP:
7973 
        break
7974 
      if fid == 0:
483 rajveer 7975 
        if ftype == TType.LIST:
7976 
          self.success = []
5031 varun.gupt 7977 
          (_etype87, _size84) = iprot.readListBegin()
7978 
          for _i88 in xrange(_size84):
7979 
            _elem89 = Order()
7980 
            _elem89.read(iprot)
7981 
            self.success.append(_elem89)
483 rajveer 7982 
          iprot.readListEnd()
94 ashish 7983 
        else:
7984 
          iprot.skip(ftype)
7985 
      elif fid == 1:
7986 
        if ftype == TType.STRUCT:
7987 
          self.ex = TransactionServiceException()
7988 
          self.ex.read(iprot)
7989 
        else:
7990 
          iprot.skip(ftype)
7991 
      else:
7992 
        iprot.skip(ftype)
7993 
      iprot.readFieldEnd()
7994 
    iprot.readStructEnd()
7995 
 
7996 
  def write(self, oprot):
7997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7999 
      return
483 rajveer 8000 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8001 
    if self.success is not None:
483 rajveer 8002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8004 
      for iter90 in self.success:
8005 
        iter90.write(oprot)
483 rajveer 8006 
      oprot.writeListEnd()
94 ashish 8007 
      oprot.writeFieldEnd()
3431 rajveer 8008 
    if self.ex is not None:
94 ashish 8009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8010 
      self.ex.write(oprot)
8011 
      oprot.writeFieldEnd()
8012 
    oprot.writeFieldStop()
8013 
    oprot.writeStructEnd()
8014 
 
3431 rajveer 8015 
  def validate(self):
8016 
    return
8017 
 
8018 
 
94 ashish 8019 
  def __repr__(self):
8020 
    L = ['%s=%r' % (key, value)
8021 
      for key, value in self.__dict__.iteritems()]
8022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8023 
 
8024 
  def __eq__(self, other):
8025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8026 
 
8027 
  def __ne__(self, other):
8028 
    return not (self == other)
8029 
 
4133 chandransh 8030 
class getOrdersInBatch_args:
8031 
  """
8032 
  Attributes:
8033 
   - statuses
8034 
   - offset
8035 
   - limit
8036 
   - warehouse_id
8037 
  """
8038 
 
8039 
  thrift_spec = (
8040 
    None, # 0
8041 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8042 
    (2, TType.I64, 'offset', None, None, ), # 2
8043 
    (3, TType.I64, 'limit', None, None, ), # 3
8044 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8045 
  )
8046 
 
8047 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8048 
    self.statuses = statuses
8049 
    self.offset = offset
8050 
    self.limit = limit
8051 
    self.warehouse_id = warehouse_id
8052 
 
8053 
  def read(self, iprot):
8054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8056 
      return
8057 
    iprot.readStructBegin()
8058 
    while True:
8059 
      (fname, ftype, fid) = iprot.readFieldBegin()
8060 
      if ftype == TType.STOP:
8061 
        break
8062 
      if fid == 1:
8063 
        if ftype == TType.LIST:
8064 
          self.statuses = []
5031 varun.gupt 8065 
          (_etype94, _size91) = iprot.readListBegin()
8066 
          for _i95 in xrange(_size91):
8067 
            _elem96 = iprot.readI32();
8068 
            self.statuses.append(_elem96)
4133 chandransh 8069 
          iprot.readListEnd()
8070 
        else:
8071 
          iprot.skip(ftype)
8072 
      elif fid == 2:
8073 
        if ftype == TType.I64:
8074 
          self.offset = iprot.readI64();
8075 
        else:
8076 
          iprot.skip(ftype)
8077 
      elif fid == 3:
8078 
        if ftype == TType.I64:
8079 
          self.limit = iprot.readI64();
8080 
        else:
8081 
          iprot.skip(ftype)
8082 
      elif fid == 4:
8083 
        if ftype == TType.I64:
8084 
          self.warehouse_id = iprot.readI64();
8085 
        else:
8086 
          iprot.skip(ftype)
8087 
      else:
8088 
        iprot.skip(ftype)
8089 
      iprot.readFieldEnd()
8090 
    iprot.readStructEnd()
8091 
 
8092 
  def write(self, oprot):
8093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8095 
      return
8096 
    oprot.writeStructBegin('getOrdersInBatch_args')
8097 
    if self.statuses is not None:
8098 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8099 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8100 
      for iter97 in self.statuses:
8101 
        oprot.writeI32(iter97)
4133 chandransh 8102 
      oprot.writeListEnd()
8103 
      oprot.writeFieldEnd()
8104 
    if self.offset is not None:
8105 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8106 
      oprot.writeI64(self.offset)
8107 
      oprot.writeFieldEnd()
8108 
    if self.limit is not None:
8109 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8110 
      oprot.writeI64(self.limit)
8111 
      oprot.writeFieldEnd()
8112 
    if self.warehouse_id is not None:
8113 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8114 
      oprot.writeI64(self.warehouse_id)
8115 
      oprot.writeFieldEnd()
8116 
    oprot.writeFieldStop()
8117 
    oprot.writeStructEnd()
8118 
 
8119 
  def validate(self):
8120 
    return
8121 
 
8122 
 
8123 
  def __repr__(self):
8124 
    L = ['%s=%r' % (key, value)
8125 
      for key, value in self.__dict__.iteritems()]
8126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8127 
 
8128 
  def __eq__(self, other):
8129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8130 
 
8131 
  def __ne__(self, other):
8132 
    return not (self == other)
8133 
 
8134 
class getOrdersInBatch_result:
8135 
  """
8136 
  Attributes:
8137 
   - success
8138 
   - ex
8139 
  """
8140 
 
8141 
  thrift_spec = (
8142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8144 
  )
8145 
 
8146 
  def __init__(self, success=None, ex=None,):
8147 
    self.success = success
8148 
    self.ex = ex
8149 
 
8150 
  def read(self, iprot):
8151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8153 
      return
8154 
    iprot.readStructBegin()
8155 
    while True:
8156 
      (fname, ftype, fid) = iprot.readFieldBegin()
8157 
      if ftype == TType.STOP:
8158 
        break
8159 
      if fid == 0:
8160 
        if ftype == TType.LIST:
8161 
          self.success = []
5031 varun.gupt 8162 
          (_etype101, _size98) = iprot.readListBegin()
8163 
          for _i102 in xrange(_size98):
8164 
            _elem103 = Order()
8165 
            _elem103.read(iprot)
8166 
            self.success.append(_elem103)
4133 chandransh 8167 
          iprot.readListEnd()
8168 
        else:
8169 
          iprot.skip(ftype)
8170 
      elif fid == 1:
8171 
        if ftype == TType.STRUCT:
8172 
          self.ex = TransactionServiceException()
8173 
          self.ex.read(iprot)
8174 
        else:
8175 
          iprot.skip(ftype)
8176 
      else:
8177 
        iprot.skip(ftype)
8178 
      iprot.readFieldEnd()
8179 
    iprot.readStructEnd()
8180 
 
8181 
  def write(self, oprot):
8182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8184 
      return
8185 
    oprot.writeStructBegin('getOrdersInBatch_result')
8186 
    if self.success is not None:
8187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8189 
      for iter104 in self.success:
8190 
        iter104.write(oprot)
4133 chandransh 8191 
      oprot.writeListEnd()
8192 
      oprot.writeFieldEnd()
8193 
    if self.ex is not None:
8194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8195 
      self.ex.write(oprot)
8196 
      oprot.writeFieldEnd()
8197 
    oprot.writeFieldStop()
8198 
    oprot.writeStructEnd()
8199 
 
8200 
  def validate(self):
8201 
    return
8202 
 
8203 
 
8204 
  def __repr__(self):
8205 
    L = ['%s=%r' % (key, value)
8206 
      for key, value in self.__dict__.iteritems()]
8207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8208 
 
8209 
  def __eq__(self, other):
8210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8211 
 
8212 
  def __ne__(self, other):
8213 
    return not (self == other)
8214 
 
8215 
class getOrderCount_args:
8216 
  """
8217 
  Attributes:
8218 
   - statuses
8219 
   - warehouseId
8220 
  """
8221 
 
8222 
  thrift_spec = (
8223 
    None, # 0
8224 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8225 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8226 
  )
8227 
 
8228 
  def __init__(self, statuses=None, warehouseId=None,):
8229 
    self.statuses = statuses
8230 
    self.warehouseId = warehouseId
8231 
 
8232 
  def read(self, iprot):
8233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8235 
      return
8236 
    iprot.readStructBegin()
8237 
    while True:
8238 
      (fname, ftype, fid) = iprot.readFieldBegin()
8239 
      if ftype == TType.STOP:
8240 
        break
8241 
      if fid == 1:
8242 
        if ftype == TType.LIST:
8243 
          self.statuses = []
5031 varun.gupt 8244 
          (_etype108, _size105) = iprot.readListBegin()
8245 
          for _i109 in xrange(_size105):
8246 
            _elem110 = iprot.readI32();
8247 
            self.statuses.append(_elem110)
4133 chandransh 8248 
          iprot.readListEnd()
8249 
        else:
8250 
          iprot.skip(ftype)
8251 
      elif fid == 2:
8252 
        if ftype == TType.I64:
8253 
          self.warehouseId = iprot.readI64();
8254 
        else:
8255 
          iprot.skip(ftype)
8256 
      else:
8257 
        iprot.skip(ftype)
8258 
      iprot.readFieldEnd()
8259 
    iprot.readStructEnd()
8260 
 
8261 
  def write(self, oprot):
8262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8264 
      return
8265 
    oprot.writeStructBegin('getOrderCount_args')
8266 
    if self.statuses is not None:
8267 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8268 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8269 
      for iter111 in self.statuses:
8270 
        oprot.writeI32(iter111)
4133 chandransh 8271 
      oprot.writeListEnd()
8272 
      oprot.writeFieldEnd()
8273 
    if self.warehouseId is not None:
8274 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8275 
      oprot.writeI64(self.warehouseId)
8276 
      oprot.writeFieldEnd()
8277 
    oprot.writeFieldStop()
8278 
    oprot.writeStructEnd()
8279 
 
8280 
  def validate(self):
8281 
    return
8282 
 
8283 
 
8284 
  def __repr__(self):
8285 
    L = ['%s=%r' % (key, value)
8286 
      for key, value in self.__dict__.iteritems()]
8287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8288 
 
8289 
  def __eq__(self, other):
8290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8291 
 
8292 
  def __ne__(self, other):
8293 
    return not (self == other)
8294 
 
8295 
class getOrderCount_result:
8296 
  """
8297 
  Attributes:
8298 
   - success
8299 
   - ex
8300 
  """
8301 
 
8302 
  thrift_spec = (
8303 
    (0, TType.I32, 'success', None, None, ), # 0
8304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8305 
  )
8306 
 
8307 
  def __init__(self, success=None, ex=None,):
8308 
    self.success = success
8309 
    self.ex = ex
8310 
 
8311 
  def read(self, iprot):
8312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8314 
      return
8315 
    iprot.readStructBegin()
8316 
    while True:
8317 
      (fname, ftype, fid) = iprot.readFieldBegin()
8318 
      if ftype == TType.STOP:
8319 
        break
8320 
      if fid == 0:
8321 
        if ftype == TType.I32:
8322 
          self.success = iprot.readI32();
8323 
        else:
8324 
          iprot.skip(ftype)
8325 
      elif fid == 1:
8326 
        if ftype == TType.STRUCT:
8327 
          self.ex = TransactionServiceException()
8328 
          self.ex.read(iprot)
8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      else:
8332 
        iprot.skip(ftype)
8333 
      iprot.readFieldEnd()
8334 
    iprot.readStructEnd()
8335 
 
8336 
  def write(self, oprot):
8337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8339 
      return
8340 
    oprot.writeStructBegin('getOrderCount_result')
8341 
    if self.success is not None:
8342 
      oprot.writeFieldBegin('success', TType.I32, 0)
8343 
      oprot.writeI32(self.success)
8344 
      oprot.writeFieldEnd()
8345 
    if self.ex is not None:
8346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8347 
      self.ex.write(oprot)
8348 
      oprot.writeFieldEnd()
8349 
    oprot.writeFieldStop()
8350 
    oprot.writeStructEnd()
8351 
 
8352 
  def validate(self):
8353 
    return
8354 
 
8355 
 
8356 
  def __repr__(self):
8357 
    L = ['%s=%r' % (key, value)
8358 
      for key, value in self.__dict__.iteritems()]
8359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8360 
 
8361 
  def __eq__(self, other):
8362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8363 
 
8364 
  def __ne__(self, other):
8365 
    return not (self == other)
8366 
 
999 varun.gupt 8367 
class getOrdersByBillingDate_args:
8368 
  """
8369 
  Attributes:
8370 
   - status
8371 
   - start_billing_date
8372 
   - end_billing_date
8373 
   - warehouse_id
8374 
  """
8375 
 
8376 
  thrift_spec = (
8377 
    None, # 0
8378 
    (1, TType.I32, 'status', None, None, ), # 1
8379 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8380 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8381 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8382 
  )
8383 
 
8384 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8385 
    self.status = status
8386 
    self.start_billing_date = start_billing_date
8387 
    self.end_billing_date = end_billing_date
8388 
    self.warehouse_id = warehouse_id
8389 
 
8390 
  def read(self, iprot):
8391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8393 
      return
8394 
    iprot.readStructBegin()
8395 
    while True:
8396 
      (fname, ftype, fid) = iprot.readFieldBegin()
8397 
      if ftype == TType.STOP:
8398 
        break
8399 
      if fid == 1:
8400 
        if ftype == TType.I32:
8401 
          self.status = iprot.readI32();
8402 
        else:
8403 
          iprot.skip(ftype)
8404 
      elif fid == 2:
8405 
        if ftype == TType.I64:
8406 
          self.start_billing_date = iprot.readI64();
8407 
        else:
8408 
          iprot.skip(ftype)
8409 
      elif fid == 3:
8410 
        if ftype == TType.I64:
8411 
          self.end_billing_date = iprot.readI64();
8412 
        else:
8413 
          iprot.skip(ftype)
8414 
      elif fid == 4:
8415 
        if ftype == TType.I64:
8416 
          self.warehouse_id = iprot.readI64();
8417 
        else:
8418 
          iprot.skip(ftype)
8419 
      else:
8420 
        iprot.skip(ftype)
8421 
      iprot.readFieldEnd()
8422 
    iprot.readStructEnd()
8423 
 
8424 
  def write(self, oprot):
8425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8427 
      return
8428 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8429 
    if self.status is not None:
999 varun.gupt 8430 
      oprot.writeFieldBegin('status', TType.I32, 1)
8431 
      oprot.writeI32(self.status)
8432 
      oprot.writeFieldEnd()
3431 rajveer 8433 
    if self.start_billing_date is not None:
999 varun.gupt 8434 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8435 
      oprot.writeI64(self.start_billing_date)
8436 
      oprot.writeFieldEnd()
3431 rajveer 8437 
    if self.end_billing_date is not None:
999 varun.gupt 8438 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8439 
      oprot.writeI64(self.end_billing_date)
8440 
      oprot.writeFieldEnd()
3431 rajveer 8441 
    if self.warehouse_id is not None:
999 varun.gupt 8442 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8443 
      oprot.writeI64(self.warehouse_id)
8444 
      oprot.writeFieldEnd()
8445 
    oprot.writeFieldStop()
8446 
    oprot.writeStructEnd()
8447 
 
3431 rajveer 8448 
  def validate(self):
8449 
    return
8450 
 
8451 
 
999 varun.gupt 8452 
  def __repr__(self):
8453 
    L = ['%s=%r' % (key, value)
8454 
      for key, value in self.__dict__.iteritems()]
8455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8456 
 
8457 
  def __eq__(self, other):
8458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8459 
 
8460 
  def __ne__(self, other):
8461 
    return not (self == other)
8462 
 
8463 
class getOrdersByBillingDate_result:
8464 
  """
8465 
  Attributes:
8466 
   - success
8467 
   - ex
8468 
  """
8469 
 
8470 
  thrift_spec = (
8471 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8473 
  )
8474 
 
8475 
  def __init__(self, success=None, ex=None,):
8476 
    self.success = success
8477 
    self.ex = ex
8478 
 
8479 
  def read(self, iprot):
8480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8482 
      return
8483 
    iprot.readStructBegin()
8484 
    while True:
8485 
      (fname, ftype, fid) = iprot.readFieldBegin()
8486 
      if ftype == TType.STOP:
8487 
        break
8488 
      if fid == 0:
8489 
        if ftype == TType.LIST:
8490 
          self.success = []
5031 varun.gupt 8491 
          (_etype115, _size112) = iprot.readListBegin()
8492 
          for _i116 in xrange(_size112):
8493 
            _elem117 = Order()
8494 
            _elem117.read(iprot)
8495 
            self.success.append(_elem117)
999 varun.gupt 8496 
          iprot.readListEnd()
8497 
        else:
8498 
          iprot.skip(ftype)
8499 
      elif fid == 1:
8500 
        if ftype == TType.STRUCT:
8501 
          self.ex = TransactionServiceException()
8502 
          self.ex.read(iprot)
8503 
        else:
8504 
          iprot.skip(ftype)
8505 
      else:
8506 
        iprot.skip(ftype)
8507 
      iprot.readFieldEnd()
8508 
    iprot.readStructEnd()
8509 
 
8510 
  def write(self, oprot):
8511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8513 
      return
8514 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8515 
    if self.success is not None:
999 varun.gupt 8516 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8517 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8518 
      for iter118 in self.success:
8519 
        iter118.write(oprot)
999 varun.gupt 8520 
      oprot.writeListEnd()
8521 
      oprot.writeFieldEnd()
3431 rajveer 8522 
    if self.ex is not None:
999 varun.gupt 8523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8524 
      self.ex.write(oprot)
8525 
      oprot.writeFieldEnd()
8526 
    oprot.writeFieldStop()
8527 
    oprot.writeStructEnd()
8528 
 
3431 rajveer 8529 
  def validate(self):
8530 
    return
8531 
 
8532 
 
999 varun.gupt 8533 
  def __repr__(self):
8534 
    L = ['%s=%r' % (key, value)
8535 
      for key, value in self.__dict__.iteritems()]
8536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8537 
 
8538 
  def __eq__(self, other):
8539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8540 
 
8541 
  def __ne__(self, other):
8542 
    return not (self == other)
8543 
 
3427 chandransh 8544 
class getOrdersByShippingDate_args:
8545 
  """
8546 
  Attributes:
8547 
   - fromShippingDate
8548 
   - toShippingDate
8549 
   - providerId
8550 
   - warehouseId
3451 chandransh 8551 
   - cod
3427 chandransh 8552 
  """
8553 
 
8554 
  thrift_spec = (
8555 
    None, # 0
8556 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8557 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8558 
    (3, TType.I64, 'providerId', None, None, ), # 3
8559 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8560 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8561 
  )
8562 
 
3451 chandransh 8563 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8564 
    self.fromShippingDate = fromShippingDate
8565 
    self.toShippingDate = toShippingDate
8566 
    self.providerId = providerId
8567 
    self.warehouseId = warehouseId
3451 chandransh 8568 
    self.cod = cod
3427 chandransh 8569 
 
8570 
  def read(self, iprot):
8571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8573 
      return
8574 
    iprot.readStructBegin()
8575 
    while True:
8576 
      (fname, ftype, fid) = iprot.readFieldBegin()
8577 
      if ftype == TType.STOP:
8578 
        break
8579 
      if fid == 1:
8580 
        if ftype == TType.I64:
8581 
          self.fromShippingDate = iprot.readI64();
8582 
        else:
8583 
          iprot.skip(ftype)
8584 
      elif fid == 2:
8585 
        if ftype == TType.I64:
8586 
          self.toShippingDate = iprot.readI64();
8587 
        else:
8588 
          iprot.skip(ftype)
8589 
      elif fid == 3:
8590 
        if ftype == TType.I64:
8591 
          self.providerId = iprot.readI64();
8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      elif fid == 4:
8595 
        if ftype == TType.I64:
8596 
          self.warehouseId = iprot.readI64();
8597 
        else:
8598 
          iprot.skip(ftype)
3451 chandransh 8599 
      elif fid == 5:
8600 
        if ftype == TType.BOOL:
8601 
          self.cod = iprot.readBool();
8602 
        else:
8603 
          iprot.skip(ftype)
3427 chandransh 8604 
      else:
8605 
        iprot.skip(ftype)
8606 
      iprot.readFieldEnd()
8607 
    iprot.readStructEnd()
8608 
 
8609 
  def write(self, oprot):
8610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8612 
      return
8613 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8614 
    if self.fromShippingDate is not None:
3427 chandransh 8615 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8616 
      oprot.writeI64(self.fromShippingDate)
8617 
      oprot.writeFieldEnd()
3431 rajveer 8618 
    if self.toShippingDate is not None:
3427 chandransh 8619 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8620 
      oprot.writeI64(self.toShippingDate)
8621 
      oprot.writeFieldEnd()
3431 rajveer 8622 
    if self.providerId is not None:
3427 chandransh 8623 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8624 
      oprot.writeI64(self.providerId)
8625 
      oprot.writeFieldEnd()
3431 rajveer 8626 
    if self.warehouseId is not None:
3427 chandransh 8627 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8628 
      oprot.writeI64(self.warehouseId)
8629 
      oprot.writeFieldEnd()
3451 chandransh 8630 
    if self.cod is not None:
8631 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8632 
      oprot.writeBool(self.cod)
8633 
      oprot.writeFieldEnd()
3427 chandransh 8634 
    oprot.writeFieldStop()
8635 
    oprot.writeStructEnd()
8636 
 
3431 rajveer 8637 
  def validate(self):
8638 
    return
8639 
 
8640 
 
3427 chandransh 8641 
  def __repr__(self):
8642 
    L = ['%s=%r' % (key, value)
8643 
      for key, value in self.__dict__.iteritems()]
8644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8645 
 
8646 
  def __eq__(self, other):
8647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8648 
 
8649 
  def __ne__(self, other):
8650 
    return not (self == other)
8651 
 
8652 
class getOrdersByShippingDate_result:
8653 
  """
8654 
  Attributes:
8655 
   - success
8656 
   - ex
8657 
  """
8658 
 
8659 
  thrift_spec = (
8660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8662 
  )
8663 
 
8664 
  def __init__(self, success=None, ex=None,):
8665 
    self.success = success
8666 
    self.ex = ex
8667 
 
8668 
  def read(self, iprot):
8669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8671 
      return
8672 
    iprot.readStructBegin()
8673 
    while True:
8674 
      (fname, ftype, fid) = iprot.readFieldBegin()
8675 
      if ftype == TType.STOP:
8676 
        break
8677 
      if fid == 0:
8678 
        if ftype == TType.LIST:
8679 
          self.success = []
5031 varun.gupt 8680 
          (_etype122, _size119) = iprot.readListBegin()
8681 
          for _i123 in xrange(_size119):
8682 
            _elem124 = Order()
8683 
            _elem124.read(iprot)
8684 
            self.success.append(_elem124)
3427 chandransh 8685 
          iprot.readListEnd()
8686 
        else:
8687 
          iprot.skip(ftype)
8688 
      elif fid == 1:
8689 
        if ftype == TType.STRUCT:
8690 
          self.ex = TransactionServiceException()
8691 
          self.ex.read(iprot)
8692 
        else:
8693 
          iprot.skip(ftype)
8694 
      else:
8695 
        iprot.skip(ftype)
8696 
      iprot.readFieldEnd()
8697 
    iprot.readStructEnd()
8698 
 
8699 
  def write(self, oprot):
8700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8702 
      return
8703 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8704 
    if self.success is not None:
3427 chandransh 8705 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8706 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8707 
      for iter125 in self.success:
8708 
        iter125.write(oprot)
3427 chandransh 8709 
      oprot.writeListEnd()
8710 
      oprot.writeFieldEnd()
3431 rajveer 8711 
    if self.ex is not None:
3427 chandransh 8712 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8713 
      self.ex.write(oprot)
8714 
      oprot.writeFieldEnd()
8715 
    oprot.writeFieldStop()
8716 
    oprot.writeStructEnd()
8717 
 
3431 rajveer 8718 
  def validate(self):
8719 
    return
8720 
 
8721 
 
3427 chandransh 8722 
  def __repr__(self):
8723 
    L = ['%s=%r' % (key, value)
8724 
      for key, value in self.__dict__.iteritems()]
8725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8726 
 
8727 
  def __eq__(self, other):
8728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8729 
 
8730 
  def __ne__(self, other):
8731 
    return not (self == other)
8732 
 
1382 varun.gupt 8733 
class getReturnableOrdersForCustomer_args:
8734 
  """
8735 
  Attributes:
8736 
   - customer_id
8737 
   - limit
8738 
  """
8739 
 
8740 
  thrift_spec = (
8741 
    None, # 0
8742 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8743 
    (2, TType.I64, 'limit', None, None, ), # 2
8744 
  )
8745 
 
8746 
  def __init__(self, customer_id=None, limit=None,):
8747 
    self.customer_id = customer_id
8748 
    self.limit = limit
8749 
 
8750 
  def read(self, iprot):
8751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8753 
      return
8754 
    iprot.readStructBegin()
8755 
    while True:
8756 
      (fname, ftype, fid) = iprot.readFieldBegin()
8757 
      if ftype == TType.STOP:
8758 
        break
8759 
      if fid == 1:
8760 
        if ftype == TType.I64:
8761 
          self.customer_id = iprot.readI64();
8762 
        else:
8763 
          iprot.skip(ftype)
8764 
      elif fid == 2:
8765 
        if ftype == TType.I64:
8766 
          self.limit = iprot.readI64();
8767 
        else:
8768 
          iprot.skip(ftype)
8769 
      else:
8770 
        iprot.skip(ftype)
8771 
      iprot.readFieldEnd()
8772 
    iprot.readStructEnd()
8773 
 
8774 
  def write(self, oprot):
8775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8777 
      return
8778 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8779 
    if self.customer_id is not None:
1382 varun.gupt 8780 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8781 
      oprot.writeI64(self.customer_id)
8782 
      oprot.writeFieldEnd()
3431 rajveer 8783 
    if self.limit is not None:
1382 varun.gupt 8784 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8785 
      oprot.writeI64(self.limit)
8786 
      oprot.writeFieldEnd()
8787 
    oprot.writeFieldStop()
8788 
    oprot.writeStructEnd()
8789 
 
3431 rajveer 8790 
  def validate(self):
8791 
    return
8792 
 
8793 
 
1382 varun.gupt 8794 
  def __repr__(self):
8795 
    L = ['%s=%r' % (key, value)
8796 
      for key, value in self.__dict__.iteritems()]
8797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8798 
 
8799 
  def __eq__(self, other):
8800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8801 
 
8802 
  def __ne__(self, other):
8803 
    return not (self == other)
8804 
 
8805 
class getReturnableOrdersForCustomer_result:
8806 
  """
8807 
  Attributes:
8808 
   - success
8809 
   - ex
8810 
  """
8811 
 
8812 
  thrift_spec = (
8813 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8815 
  )
8816 
 
8817 
  def __init__(self, success=None, ex=None,):
8818 
    self.success = success
8819 
    self.ex = ex
8820 
 
8821 
  def read(self, iprot):
8822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8824 
      return
8825 
    iprot.readStructBegin()
8826 
    while True:
8827 
      (fname, ftype, fid) = iprot.readFieldBegin()
8828 
      if ftype == TType.STOP:
8829 
        break
8830 
      if fid == 0:
8831 
        if ftype == TType.LIST:
8832 
          self.success = []
5031 varun.gupt 8833 
          (_etype129, _size126) = iprot.readListBegin()
8834 
          for _i130 in xrange(_size126):
8835 
            _elem131 = iprot.readI64();
8836 
            self.success.append(_elem131)
1382 varun.gupt 8837 
          iprot.readListEnd()
8838 
        else:
8839 
          iprot.skip(ftype)
8840 
      elif fid == 1:
8841 
        if ftype == TType.STRUCT:
8842 
          self.ex = TransactionServiceException()
8843 
          self.ex.read(iprot)
8844 
        else:
8845 
          iprot.skip(ftype)
8846 
      else:
8847 
        iprot.skip(ftype)
8848 
      iprot.readFieldEnd()
8849 
    iprot.readStructEnd()
8850 
 
8851 
  def write(self, oprot):
8852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8854 
      return
8855 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8856 
    if self.success is not None:
1382 varun.gupt 8857 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8858 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8859 
      for iter132 in self.success:
8860 
        oprot.writeI64(iter132)
1382 varun.gupt 8861 
      oprot.writeListEnd()
8862 
      oprot.writeFieldEnd()
3431 rajveer 8863 
    if self.ex is not None:
1382 varun.gupt 8864 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8865 
      self.ex.write(oprot)
8866 
      oprot.writeFieldEnd()
8867 
    oprot.writeFieldStop()
8868 
    oprot.writeStructEnd()
8869 
 
3431 rajveer 8870 
  def validate(self):
8871 
    return
8872 
 
8873 
 
1382 varun.gupt 8874 
  def __repr__(self):
8875 
    L = ['%s=%r' % (key, value)
8876 
      for key, value in self.__dict__.iteritems()]
8877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8878 
 
8879 
  def __eq__(self, other):
8880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8881 
 
8882 
  def __ne__(self, other):
8883 
    return not (self == other)
8884 
 
8885 
class getCancellableOrdersForCustomer_args:
8886 
  """
8887 
  Attributes:
8888 
   - customer_id
8889 
   - limit
8890 
  """
8891 
 
8892 
  thrift_spec = (
8893 
    None, # 0
8894 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8895 
    (2, TType.I64, 'limit', None, None, ), # 2
8896 
  )
8897 
 
8898 
  def __init__(self, customer_id=None, limit=None,):
8899 
    self.customer_id = customer_id
8900 
    self.limit = limit
8901 
 
8902 
  def read(self, iprot):
8903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8905 
      return
8906 
    iprot.readStructBegin()
8907 
    while True:
8908 
      (fname, ftype, fid) = iprot.readFieldBegin()
8909 
      if ftype == TType.STOP:
8910 
        break
8911 
      if fid == 1:
8912 
        if ftype == TType.I64:
8913 
          self.customer_id = iprot.readI64();
8914 
        else:
8915 
          iprot.skip(ftype)
8916 
      elif fid == 2:
8917 
        if ftype == TType.I64:
8918 
          self.limit = iprot.readI64();
8919 
        else:
8920 
          iprot.skip(ftype)
8921 
      else:
8922 
        iprot.skip(ftype)
8923 
      iprot.readFieldEnd()
8924 
    iprot.readStructEnd()
8925 
 
8926 
  def write(self, oprot):
8927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8929 
      return
8930 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8931 
    if self.customer_id is not None:
1382 varun.gupt 8932 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8933 
      oprot.writeI64(self.customer_id)
8934 
      oprot.writeFieldEnd()
3431 rajveer 8935 
    if self.limit is not None:
1382 varun.gupt 8936 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8937 
      oprot.writeI64(self.limit)
8938 
      oprot.writeFieldEnd()
8939 
    oprot.writeFieldStop()
8940 
    oprot.writeStructEnd()
8941 
 
3431 rajveer 8942 
  def validate(self):
8943 
    return
8944 
 
8945 
 
1382 varun.gupt 8946 
  def __repr__(self):
8947 
    L = ['%s=%r' % (key, value)
8948 
      for key, value in self.__dict__.iteritems()]
8949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8950 
 
8951 
  def __eq__(self, other):
8952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8953 
 
8954 
  def __ne__(self, other):
8955 
    return not (self == other)
8956 
 
8957 
class getCancellableOrdersForCustomer_result:
8958 
  """
8959 
  Attributes:
8960 
   - success
8961 
   - ex
8962 
  """
8963 
 
8964 
  thrift_spec = (
8965 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8966 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8967 
  )
8968 
 
8969 
  def __init__(self, success=None, ex=None,):
8970 
    self.success = success
8971 
    self.ex = ex
8972 
 
8973 
  def read(self, iprot):
8974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8976 
      return
8977 
    iprot.readStructBegin()
8978 
    while True:
8979 
      (fname, ftype, fid) = iprot.readFieldBegin()
8980 
      if ftype == TType.STOP:
8981 
        break
8982 
      if fid == 0:
8983 
        if ftype == TType.LIST:
8984 
          self.success = []
5031 varun.gupt 8985 
          (_etype136, _size133) = iprot.readListBegin()
8986 
          for _i137 in xrange(_size133):
8987 
            _elem138 = iprot.readI64();
8988 
            self.success.append(_elem138)
1382 varun.gupt 8989 
          iprot.readListEnd()
8990 
        else:
8991 
          iprot.skip(ftype)
8992 
      elif fid == 1:
8993 
        if ftype == TType.STRUCT:
8994 
          self.ex = TransactionServiceException()
8995 
          self.ex.read(iprot)
8996 
        else:
8997 
          iprot.skip(ftype)
8998 
      else:
8999 
        iprot.skip(ftype)
9000 
      iprot.readFieldEnd()
9001 
    iprot.readStructEnd()
9002 
 
9003 
  def write(self, oprot):
9004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9006 
      return
9007 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9008 
    if self.success is not None:
1382 varun.gupt 9009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9010 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9011 
      for iter139 in self.success:
9012 
        oprot.writeI64(iter139)
1382 varun.gupt 9013 
      oprot.writeListEnd()
9014 
      oprot.writeFieldEnd()
3431 rajveer 9015 
    if self.ex is not None:
1382 varun.gupt 9016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9017 
      self.ex.write(oprot)
9018 
      oprot.writeFieldEnd()
9019 
    oprot.writeFieldStop()
9020 
    oprot.writeStructEnd()
9021 
 
3431 rajveer 9022 
  def validate(self):
9023 
    return
9024 
 
9025 
 
1382 varun.gupt 9026 
  def __repr__(self):
9027 
    L = ['%s=%r' % (key, value)
9028 
      for key, value in self.__dict__.iteritems()]
9029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9030 
 
9031 
  def __eq__(self, other):
9032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9033 
 
9034 
  def __ne__(self, other):
9035 
    return not (self == other)
9036 
 
483 rajveer 9037 
class changeOrderStatus_args:
94 ashish 9038 
  """
9039 
  Attributes:
483 rajveer 9040 
   - orderId
9041 
   - status
9042 
   - description
94 ashish 9043 
  """
9044 
 
9045 
  thrift_spec = (
9046 
    None, # 0
483 rajveer 9047 
    (1, TType.I64, 'orderId', None, None, ), # 1
9048 
    (2, TType.I32, 'status', None, None, ), # 2
9049 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9050 
  )
9051 
 
483 rajveer 9052 
  def __init__(self, orderId=None, status=None, description=None,):
9053 
    self.orderId = orderId
9054 
    self.status = status
9055 
    self.description = description
94 ashish 9056 
 
9057 
  def read(self, iprot):
9058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9060 
      return
9061 
    iprot.readStructBegin()
9062 
    while True:
9063 
      (fname, ftype, fid) = iprot.readFieldBegin()
9064 
      if ftype == TType.STOP:
9065 
        break
9066 
      if fid == 1:
9067 
        if ftype == TType.I64:
483 rajveer 9068 
          self.orderId = iprot.readI64();
94 ashish 9069 
        else:
9070 
          iprot.skip(ftype)
9071 
      elif fid == 2:
483 rajveer 9072 
        if ftype == TType.I32:
9073 
          self.status = iprot.readI32();
94 ashish 9074 
        else:
9075 
          iprot.skip(ftype)
483 rajveer 9076 
      elif fid == 3:
9077 
        if ftype == TType.STRING:
9078 
          self.description = iprot.readString();
9079 
        else:
9080 
          iprot.skip(ftype)
94 ashish 9081 
      else:
9082 
        iprot.skip(ftype)
9083 
      iprot.readFieldEnd()
9084 
    iprot.readStructEnd()
9085 
 
9086 
  def write(self, oprot):
9087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9089 
      return
483 rajveer 9090 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9091 
    if self.orderId is not None:
483 rajveer 9092 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9093 
      oprot.writeI64(self.orderId)
94 ashish 9094 
      oprot.writeFieldEnd()
3431 rajveer 9095 
    if self.status is not None:
483 rajveer 9096 
      oprot.writeFieldBegin('status', TType.I32, 2)
9097 
      oprot.writeI32(self.status)
94 ashish 9098 
      oprot.writeFieldEnd()
3431 rajveer 9099 
    if self.description is not None:
483 rajveer 9100 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9101 
      oprot.writeString(self.description)
9102 
      oprot.writeFieldEnd()
94 ashish 9103 
    oprot.writeFieldStop()
9104 
    oprot.writeStructEnd()
9105 
 
3431 rajveer 9106 
  def validate(self):
9107 
    return
9108 
 
9109 
 
94 ashish 9110 
  def __repr__(self):
9111 
    L = ['%s=%r' % (key, value)
9112 
      for key, value in self.__dict__.iteritems()]
9113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9114 
 
9115 
  def __eq__(self, other):
9116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9117 
 
9118 
  def __ne__(self, other):
9119 
    return not (self == other)
9120 
 
483 rajveer 9121 
class changeOrderStatus_result:
94 ashish 9122 
  """
9123 
  Attributes:
9124 
   - success
9125 
   - ex
9126 
  """
9127 
 
9128 
  thrift_spec = (
9129 
    (0, TType.BOOL, 'success', None, None, ), # 0
9130 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9131 
  )
9132 
 
9133 
  def __init__(self, success=None, ex=None,):
9134 
    self.success = success
9135 
    self.ex = ex
9136 
 
9137 
  def read(self, iprot):
9138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9140 
      return
9141 
    iprot.readStructBegin()
9142 
    while True:
9143 
      (fname, ftype, fid) = iprot.readFieldBegin()
9144 
      if ftype == TType.STOP:
9145 
        break
9146 
      if fid == 0:
9147 
        if ftype == TType.BOOL:
9148 
          self.success = iprot.readBool();
9149 
        else:
9150 
          iprot.skip(ftype)
9151 
      elif fid == 1:
9152 
        if ftype == TType.STRUCT:
9153 
          self.ex = TransactionServiceException()
9154 
          self.ex.read(iprot)
9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      else:
9158 
        iprot.skip(ftype)
9159 
      iprot.readFieldEnd()
9160 
    iprot.readStructEnd()
9161 
 
9162 
  def write(self, oprot):
9163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9165 
      return
483 rajveer 9166 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9167 
    if self.success is not None:
94 ashish 9168 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9169 
      oprot.writeBool(self.success)
9170 
      oprot.writeFieldEnd()
3431 rajveer 9171 
    if self.ex is not None:
94 ashish 9172 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9173 
      self.ex.write(oprot)
9174 
      oprot.writeFieldEnd()
9175 
    oprot.writeFieldStop()
9176 
    oprot.writeStructEnd()
9177 
 
3431 rajveer 9178 
  def validate(self):
9179 
    return
9180 
 
9181 
 
94 ashish 9182 
  def __repr__(self):
9183 
    L = ['%s=%r' % (key, value)
9184 
      for key, value in self.__dict__.iteritems()]
9185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9186 
 
9187 
  def __eq__(self, other):
9188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9189 
 
9190 
  def __ne__(self, other):
9191 
    return not (self == other)
9192 
 
3064 chandransh 9193 
class getOrdersForTransaction_args:
494 rajveer 9194 
  """
9195 
  Attributes:
3064 chandransh 9196 
   - transactionId
9197 
   - customerId
494 rajveer 9198 
  """
9199 
 
9200 
  thrift_spec = (
9201 
    None, # 0
3064 chandransh 9202 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9203 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9204 
  )
9205 
 
3064 chandransh 9206 
  def __init__(self, transactionId=None, customerId=None,):
9207 
    self.transactionId = transactionId
9208 
    self.customerId = customerId
494 rajveer 9209 
 
9210 
  def read(self, iprot):
9211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9213 
      return
9214 
    iprot.readStructBegin()
9215 
    while True:
9216 
      (fname, ftype, fid) = iprot.readFieldBegin()
9217 
      if ftype == TType.STOP:
9218 
        break
9219 
      if fid == 1:
9220 
        if ftype == TType.I64:
3064 chandransh 9221 
          self.transactionId = iprot.readI64();
494 rajveer 9222 
        else:
9223 
          iprot.skip(ftype)
9224 
      elif fid == 2:
3064 chandransh 9225 
        if ftype == TType.I64:
9226 
          self.customerId = iprot.readI64();
494 rajveer 9227 
        else:
9228 
          iprot.skip(ftype)
9229 
      else:
9230 
        iprot.skip(ftype)
9231 
      iprot.readFieldEnd()
9232 
    iprot.readStructEnd()
9233 
 
9234 
  def write(self, oprot):
9235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9237 
      return
3064 chandransh 9238 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9239 
    if self.transactionId is not None:
3064 chandransh 9240 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9241 
      oprot.writeI64(self.transactionId)
494 rajveer 9242 
      oprot.writeFieldEnd()
3431 rajveer 9243 
    if self.customerId is not None:
3064 chandransh 9244 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9245 
      oprot.writeI64(self.customerId)
494 rajveer 9246 
      oprot.writeFieldEnd()
9247 
    oprot.writeFieldStop()
9248 
    oprot.writeStructEnd()
9249 
 
3431 rajveer 9250 
  def validate(self):
9251 
    return
9252 
 
9253 
 
494 rajveer 9254 
  def __repr__(self):
9255 
    L = ['%s=%r' % (key, value)
9256 
      for key, value in self.__dict__.iteritems()]
9257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9258 
 
9259 
  def __eq__(self, other):
9260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9261 
 
9262 
  def __ne__(self, other):
9263 
    return not (self == other)
9264 
 
3064 chandransh 9265 
class getOrdersForTransaction_result:
494 rajveer 9266 
  """
9267 
  Attributes:
9268 
   - success
9269 
   - ex
9270 
  """
9271 
 
9272 
  thrift_spec = (
3064 chandransh 9273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9275 
  )
9276 
 
9277 
  def __init__(self, success=None, ex=None,):
9278 
    self.success = success
9279 
    self.ex = ex
9280 
 
9281 
  def read(self, iprot):
9282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9284 
      return
9285 
    iprot.readStructBegin()
9286 
    while True:
9287 
      (fname, ftype, fid) = iprot.readFieldBegin()
9288 
      if ftype == TType.STOP:
9289 
        break
9290 
      if fid == 0:
3064 chandransh 9291 
        if ftype == TType.LIST:
9292 
          self.success = []
5031 varun.gupt 9293 
          (_etype143, _size140) = iprot.readListBegin()
9294 
          for _i144 in xrange(_size140):
9295 
            _elem145 = Order()
9296 
            _elem145.read(iprot)
9297 
            self.success.append(_elem145)
3064 chandransh 9298 
          iprot.readListEnd()
494 rajveer 9299 
        else:
9300 
          iprot.skip(ftype)
9301 
      elif fid == 1:
9302 
        if ftype == TType.STRUCT:
9303 
          self.ex = TransactionServiceException()
9304 
          self.ex.read(iprot)
9305 
        else:
9306 
          iprot.skip(ftype)
9307 
      else:
9308 
        iprot.skip(ftype)
9309 
      iprot.readFieldEnd()
9310 
    iprot.readStructEnd()
9311 
 
9312 
  def write(self, oprot):
9313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9315 
      return
3064 chandransh 9316 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9317 
    if self.success is not None:
3064 chandransh 9318 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9319 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9320 
      for iter146 in self.success:
9321 
        iter146.write(oprot)
3064 chandransh 9322 
      oprot.writeListEnd()
494 rajveer 9323 
      oprot.writeFieldEnd()
3431 rajveer 9324 
    if self.ex is not None:
494 rajveer 9325 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9326 
      self.ex.write(oprot)
9327 
      oprot.writeFieldEnd()
9328 
    oprot.writeFieldStop()
9329 
    oprot.writeStructEnd()
9330 
 
3431 rajveer 9331 
  def validate(self):
9332 
    return
9333 
 
9334 
 
494 rajveer 9335 
  def __repr__(self):
9336 
    L = ['%s=%r' % (key, value)
9337 
      for key, value in self.__dict__.iteritems()]
9338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9339 
 
9340 
  def __eq__(self, other):
9341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9342 
 
9343 
  def __ne__(self, other):
9344 
    return not (self == other)
9345 
 
3064 chandransh 9346 
class getOrdersForCustomer_args:
1149 chandransh 9347 
  """
9348 
  Attributes:
3064 chandransh 9349 
   - customerId
9350 
   - from_date
9351 
   - to_date
9352 
   - statuses
1149 chandransh 9353 
  """
9354 
 
9355 
  thrift_spec = (
9356 
    None, # 0
3064 chandransh 9357 
    (1, TType.I64, 'customerId', None, None, ), # 1
9358 
    (2, TType.I64, 'from_date', None, None, ), # 2
9359 
    (3, TType.I64, 'to_date', None, None, ), # 3
9360 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9361 
  )
9362 
 
3064 chandransh 9363 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9364 
    self.customerId = customerId
9365 
    self.from_date = from_date
9366 
    self.to_date = to_date
9367 
    self.statuses = statuses
1149 chandransh 9368 
 
9369 
  def read(self, iprot):
9370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9372 
      return
9373 
    iprot.readStructBegin()
9374 
    while True:
9375 
      (fname, ftype, fid) = iprot.readFieldBegin()
9376 
      if ftype == TType.STOP:
9377 
        break
9378 
      if fid == 1:
9379 
        if ftype == TType.I64:
3064 chandransh 9380 
          self.customerId = iprot.readI64();
1149 chandransh 9381 
        else:
9382 
          iprot.skip(ftype)
9383 
      elif fid == 2:
9384 
        if ftype == TType.I64:
3064 chandransh 9385 
          self.from_date = iprot.readI64();
1149 chandransh 9386 
        else:
9387 
          iprot.skip(ftype)
2783 chandransh 9388 
      elif fid == 3:
9389 
        if ftype == TType.I64:
3064 chandransh 9390 
          self.to_date = iprot.readI64();
2783 chandransh 9391 
        else:
9392 
          iprot.skip(ftype)
9393 
      elif fid == 4:
3064 chandransh 9394 
        if ftype == TType.LIST:
9395 
          self.statuses = []
5031 varun.gupt 9396 
          (_etype150, _size147) = iprot.readListBegin()
9397 
          for _i151 in xrange(_size147):
9398 
            _elem152 = iprot.readI32();
9399 
            self.statuses.append(_elem152)
3064 chandransh 9400 
          iprot.readListEnd()
2783 chandransh 9401 
        else:
9402 
          iprot.skip(ftype)
1149 chandransh 9403 
      else:
9404 
        iprot.skip(ftype)
9405 
      iprot.readFieldEnd()
9406 
    iprot.readStructEnd()
9407 
 
9408 
  def write(self, oprot):
9409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9411 
      return
3064 chandransh 9412 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9413 
    if self.customerId is not None:
3064 chandransh 9414 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9415 
      oprot.writeI64(self.customerId)
1149 chandransh 9416 
      oprot.writeFieldEnd()
3431 rajveer 9417 
    if self.from_date is not None:
3064 chandransh 9418 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9419 
      oprot.writeI64(self.from_date)
1149 chandransh 9420 
      oprot.writeFieldEnd()
3431 rajveer 9421 
    if self.to_date is not None:
3064 chandransh 9422 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9423 
      oprot.writeI64(self.to_date)
2783 chandransh 9424 
      oprot.writeFieldEnd()
3431 rajveer 9425 
    if self.statuses is not None:
3064 chandransh 9426 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9427 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9428 
      for iter153 in self.statuses:
9429 
        oprot.writeI32(iter153)
3064 chandransh 9430 
      oprot.writeListEnd()
2783 chandransh 9431 
      oprot.writeFieldEnd()
1149 chandransh 9432 
    oprot.writeFieldStop()
9433 
    oprot.writeStructEnd()
9434 
 
3431 rajveer 9435 
  def validate(self):
9436 
    return
9437 
 
9438 
 
1149 chandransh 9439 
  def __repr__(self):
9440 
    L = ['%s=%r' % (key, value)
9441 
      for key, value in self.__dict__.iteritems()]
9442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9443 
 
9444 
  def __eq__(self, other):
9445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9446 
 
9447 
  def __ne__(self, other):
9448 
    return not (self == other)
9449 
 
3064 chandransh 9450 
class getOrdersForCustomer_result:
1149 chandransh 9451 
  """
9452 
  Attributes:
9453 
   - success
9454 
   - ex
9455 
  """
9456 
 
9457 
  thrift_spec = (
3064 chandransh 9458 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9460 
  )
9461 
 
9462 
  def __init__(self, success=None, ex=None,):
9463 
    self.success = success
9464 
    self.ex = ex
9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 0:
3064 chandransh 9476 
        if ftype == TType.LIST:
9477 
          self.success = []
5031 varun.gupt 9478 
          (_etype157, _size154) = iprot.readListBegin()
9479 
          for _i158 in xrange(_size154):
9480 
            _elem159 = Order()
9481 
            _elem159.read(iprot)
9482 
            self.success.append(_elem159)
3064 chandransh 9483 
          iprot.readListEnd()
1149 chandransh 9484 
        else:
9485 
          iprot.skip(ftype)
9486 
      elif fid == 1:
9487 
        if ftype == TType.STRUCT:
9488 
          self.ex = TransactionServiceException()
9489 
          self.ex.read(iprot)
9490 
        else:
9491 
          iprot.skip(ftype)
9492 
      else:
9493 
        iprot.skip(ftype)
9494 
      iprot.readFieldEnd()
9495 
    iprot.readStructEnd()
9496 
 
9497 
  def write(self, oprot):
9498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9500 
      return
3064 chandransh 9501 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9502 
    if self.success is not None:
3064 chandransh 9503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9504 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9505 
      for iter160 in self.success:
9506 
        iter160.write(oprot)
3064 chandransh 9507 
      oprot.writeListEnd()
1149 chandransh 9508 
      oprot.writeFieldEnd()
3431 rajveer 9509 
    if self.ex is not None:
1149 chandransh 9510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9511 
      self.ex.write(oprot)
9512 
      oprot.writeFieldEnd()
9513 
    oprot.writeFieldStop()
9514 
    oprot.writeStructEnd()
9515 
 
3431 rajveer 9516 
  def validate(self):
9517 
    return
9518 
 
9519 
 
1149 chandransh 9520 
  def __repr__(self):
9521 
    L = ['%s=%r' % (key, value)
9522 
      for key, value in self.__dict__.iteritems()]
9523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9524 
 
9525 
  def __eq__(self, other):
9526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9527 
 
9528 
  def __ne__(self, other):
9529 
    return not (self == other)
9530 
 
3064 chandransh 9531 
class createOrder_args:
921 rajveer 9532 
  """
9533 
  Attributes:
3064 chandransh 9534 
   - order
921 rajveer 9535 
  """
9536 
 
9537 
  thrift_spec = (
9538 
    None, # 0
3064 chandransh 9539 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9540 
  )
9541 
 
3064 chandransh 9542 
  def __init__(self, order=None,):
9543 
    self.order = order
921 rajveer 9544 
 
9545 
  def read(self, iprot):
9546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9548 
      return
9549 
    iprot.readStructBegin()
9550 
    while True:
9551 
      (fname, ftype, fid) = iprot.readFieldBegin()
9552 
      if ftype == TType.STOP:
9553 
        break
9554 
      if fid == 1:
3064 chandransh 9555 
        if ftype == TType.STRUCT:
9556 
          self.order = Order()
9557 
          self.order.read(iprot)
921 rajveer 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('createOrder_args')
3431 rajveer 9570 
    if self.order is not None:
3064 chandransh 9571 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9572 
      self.order.write(oprot)
921 rajveer 9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
3431 rajveer 9577 
  def validate(self):
9578 
    return
9579 
 
9580 
 
921 rajveer 9581 
  def __repr__(self):
9582 
    L = ['%s=%r' % (key, value)
9583 
      for key, value in self.__dict__.iteritems()]
9584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9585 
 
9586 
  def __eq__(self, other):
9587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9588 
 
9589 
  def __ne__(self, other):
9590 
    return not (self == other)
9591 
 
3064 chandransh 9592 
class createOrder_result:
921 rajveer 9593 
  """
9594 
  Attributes:
9595 
   - success
9596 
   - ex
9597 
  """
9598 
 
9599 
  thrift_spec = (
3064 chandransh 9600 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9602 
  )
9603 
 
9604 
  def __init__(self, success=None, ex=None,):
9605 
    self.success = success
9606 
    self.ex = ex
9607 
 
9608 
  def read(self, iprot):
9609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9611 
      return
9612 
    iprot.readStructBegin()
9613 
    while True:
9614 
      (fname, ftype, fid) = iprot.readFieldBegin()
9615 
      if ftype == TType.STOP:
9616 
        break
9617 
      if fid == 0:
3064 chandransh 9618 
        if ftype == TType.I64:
9619 
          self.success = iprot.readI64();
921 rajveer 9620 
        else:
9621 
          iprot.skip(ftype)
9622 
      elif fid == 1:
9623 
        if ftype == TType.STRUCT:
9624 
          self.ex = TransactionServiceException()
9625 
          self.ex.read(iprot)
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_result')
3431 rajveer 9638 
    if self.success is not None:
3064 chandransh 9639 
      oprot.writeFieldBegin('success', TType.I64, 0)
9640 
      oprot.writeI64(self.success)
921 rajveer 9641 
      oprot.writeFieldEnd()
3431 rajveer 9642 
    if self.ex is not None:
921 rajveer 9643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9644 
      self.ex.write(oprot)
9645 
      oprot.writeFieldEnd()
9646 
    oprot.writeFieldStop()
9647 
    oprot.writeStructEnd()
9648 
 
3431 rajveer 9649 
  def validate(self):
9650 
    return
9651 
 
9652 
 
921 rajveer 9653 
  def __repr__(self):
9654 
    L = ['%s=%r' % (key, value)
9655 
      for key, value in self.__dict__.iteritems()]
9656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9657 
 
9658 
  def __eq__(self, other):
9659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9660 
 
9661 
  def __ne__(self, other):
9662 
    return not (self == other)
9663 
 
3064 chandransh 9664 
class getOrder_args:
921 rajveer 9665 
  """
9666 
  Attributes:
3064 chandransh 9667 
   - id
921 rajveer 9668 
  """
9669 
 
9670 
  thrift_spec = (
9671 
    None, # 0
3064 chandransh 9672 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9673 
  )
9674 
 
3064 chandransh 9675 
  def __init__(self, id=None,):
9676 
    self.id = id
921 rajveer 9677 
 
9678 
  def read(self, iprot):
9679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9681 
      return
9682 
    iprot.readStructBegin()
9683 
    while True:
9684 
      (fname, ftype, fid) = iprot.readFieldBegin()
9685 
      if ftype == TType.STOP:
9686 
        break
9687 
      if fid == 1:
9688 
        if ftype == TType.I64:
3064 chandransh 9689 
          self.id = iprot.readI64();
921 rajveer 9690 
        else:
9691 
          iprot.skip(ftype)
9692 
      else:
9693 
        iprot.skip(ftype)
9694 
      iprot.readFieldEnd()
9695 
    iprot.readStructEnd()
9696 
 
9697 
  def write(self, oprot):
9698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9700 
      return
3064 chandransh 9701 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9702 
    if self.id is not None:
3064 chandransh 9703 
      oprot.writeFieldBegin('id', TType.I64, 1)
9704 
      oprot.writeI64(self.id)
921 rajveer 9705 
      oprot.writeFieldEnd()
9706 
    oprot.writeFieldStop()
9707 
    oprot.writeStructEnd()
9708 
 
3431 rajveer 9709 
  def validate(self):
9710 
    return
9711 
 
9712 
 
921 rajveer 9713 
  def __repr__(self):
9714 
    L = ['%s=%r' % (key, value)
9715 
      for key, value in self.__dict__.iteritems()]
9716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9717 
 
9718 
  def __eq__(self, other):
9719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9720 
 
9721 
  def __ne__(self, other):
9722 
    return not (self == other)
9723 
 
3064 chandransh 9724 
class getOrder_result:
921 rajveer 9725 
  """
9726 
  Attributes:
9727 
   - success
9728 
   - ex
9729 
  """
9730 
 
9731 
  thrift_spec = (
3064 chandransh 9732 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9734 
  )
9735 
 
9736 
  def __init__(self, success=None, ex=None,):
9737 
    self.success = success
9738 
    self.ex = ex
9739 
 
9740 
  def read(self, iprot):
9741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9743 
      return
9744 
    iprot.readStructBegin()
9745 
    while True:
9746 
      (fname, ftype, fid) = iprot.readFieldBegin()
9747 
      if ftype == TType.STOP:
9748 
        break
9749 
      if fid == 0:
3064 chandransh 9750 
        if ftype == TType.STRUCT:
9751 
          self.success = Order()
9752 
          self.success.read(iprot)
921 rajveer 9753 
        else:
9754 
          iprot.skip(ftype)
9755 
      elif fid == 1:
9756 
        if ftype == TType.STRUCT:
9757 
          self.ex = TransactionServiceException()
9758 
          self.ex.read(iprot)
9759 
        else:
9760 
          iprot.skip(ftype)
9761 
      else:
9762 
        iprot.skip(ftype)
9763 
      iprot.readFieldEnd()
9764 
    iprot.readStructEnd()
9765 
 
9766 
  def write(self, oprot):
9767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9769 
      return
3064 chandransh 9770 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9771 
    if self.success is not None:
3064 chandransh 9772 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9773 
      self.success.write(oprot)
921 rajveer 9774 
      oprot.writeFieldEnd()
3431 rajveer 9775 
    if self.ex is not None:
921 rajveer 9776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9777 
      self.ex.write(oprot)
9778 
      oprot.writeFieldEnd()
9779 
    oprot.writeFieldStop()
9780 
    oprot.writeStructEnd()
9781 
 
3431 rajveer 9782 
  def validate(self):
9783 
    return
9784 
 
9785 
 
921 rajveer 9786 
  def __repr__(self):
9787 
    L = ['%s=%r' % (key, value)
9788 
      for key, value in self.__dict__.iteritems()]
9789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9790 
 
9791 
  def __eq__(self, other):
9792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9793 
 
9794 
  def __ne__(self, other):
9795 
    return not (self == other)
9796 
 
3064 chandransh 9797 
class getLineItemsForOrder_args:
94 ashish 9798 
  """
9799 
  Attributes:
3064 chandransh 9800 
   - orderId
94 ashish 9801 
  """
9802 
 
9803 
  thrift_spec = (
9804 
    None, # 0
3064 chandransh 9805 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9806 
  )
9807 
 
3064 chandransh 9808 
  def __init__(self, orderId=None,):
9809 
    self.orderId = orderId
94 ashish 9810 
 
9811 
  def read(self, iprot):
9812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9814 
      return
9815 
    iprot.readStructBegin()
9816 
    while True:
9817 
      (fname, ftype, fid) = iprot.readFieldBegin()
9818 
      if ftype == TType.STOP:
9819 
        break
9820 
      if fid == 1:
9821 
        if ftype == TType.I64:
3064 chandransh 9822 
          self.orderId = iprot.readI64();
94 ashish 9823 
        else:
9824 
          iprot.skip(ftype)
9825 
      else:
9826 
        iprot.skip(ftype)
9827 
      iprot.readFieldEnd()
9828 
    iprot.readStructEnd()
9829 
 
9830 
  def write(self, oprot):
9831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9833 
      return
3064 chandransh 9834 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9835 
    if self.orderId is not None:
3064 chandransh 9836 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9837 
      oprot.writeI64(self.orderId)
94 ashish 9838 
      oprot.writeFieldEnd()
9839 
    oprot.writeFieldStop()
9840 
    oprot.writeStructEnd()
9841 
 
3431 rajveer 9842 
  def validate(self):
9843 
    return
9844 
 
9845 
 
94 ashish 9846 
  def __repr__(self):
9847 
    L = ['%s=%r' % (key, value)
9848 
      for key, value in self.__dict__.iteritems()]
9849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9850 
 
9851 
  def __eq__(self, other):
9852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9853 
 
9854 
  def __ne__(self, other):
9855 
    return not (self == other)
9856 
 
3064 chandransh 9857 
class getLineItemsForOrder_result:
94 ashish 9858 
  """
9859 
  Attributes:
9860 
   - success
9861 
   - ex
9862 
  """
9863 
 
9864 
  thrift_spec = (
3064 chandransh 9865 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9867 
  )
9868 
 
9869 
  def __init__(self, success=None, ex=None,):
9870 
    self.success = success
9871 
    self.ex = ex
9872 
 
9873 
  def read(self, iprot):
9874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9876 
      return
9877 
    iprot.readStructBegin()
9878 
    while True:
9879 
      (fname, ftype, fid) = iprot.readFieldBegin()
9880 
      if ftype == TType.STOP:
9881 
        break
9882 
      if fid == 0:
483 rajveer 9883 
        if ftype == TType.LIST:
9884 
          self.success = []
5031 varun.gupt 9885 
          (_etype164, _size161) = iprot.readListBegin()
9886 
          for _i165 in xrange(_size161):
9887 
            _elem166 = LineItem()
9888 
            _elem166.read(iprot)
9889 
            self.success.append(_elem166)
483 rajveer 9890 
          iprot.readListEnd()
94 ashish 9891 
        else:
9892 
          iprot.skip(ftype)
9893 
      elif fid == 1:
9894 
        if ftype == TType.STRUCT:
9895 
          self.ex = TransactionServiceException()
9896 
          self.ex.read(iprot)
9897 
        else:
9898 
          iprot.skip(ftype)
9899 
      else:
9900 
        iprot.skip(ftype)
9901 
      iprot.readFieldEnd()
9902 
    iprot.readStructEnd()
9903 
 
9904 
  def write(self, oprot):
9905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9907 
      return
3064 chandransh 9908 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9909 
    if self.success is not None:
483 rajveer 9910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9911 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9912 
      for iter167 in self.success:
9913 
        iter167.write(oprot)
483 rajveer 9914 
      oprot.writeListEnd()
94 ashish 9915 
      oprot.writeFieldEnd()
3431 rajveer 9916 
    if self.ex is not None:
94 ashish 9917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9918 
      self.ex.write(oprot)
9919 
      oprot.writeFieldEnd()
9920 
    oprot.writeFieldStop()
9921 
    oprot.writeStructEnd()
9922 
 
3431 rajveer 9923 
  def validate(self):
9924 
    return
9925 
 
9926 
 
94 ashish 9927 
  def __repr__(self):
9928 
    L = ['%s=%r' % (key, value)
9929 
      for key, value in self.__dict__.iteritems()]
9930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9931 
 
9932 
  def __eq__(self, other):
9933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9934 
 
9935 
  def __ne__(self, other):
9936 
    return not (self == other)
9937 
 
4999 phani.kuma 9938 
class getOrderList_args:
9939 
  """
9940 
  Attributes:
9941 
   - order_ids
9942 
  """
9943 
 
9944 
  thrift_spec = (
9945 
    None, # 0
9946 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9947 
  )
9948 
 
9949 
  def __init__(self, order_ids=None,):
9950 
    self.order_ids = order_ids
9951 
 
9952 
  def read(self, iprot):
9953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9955 
      return
9956 
    iprot.readStructBegin()
9957 
    while True:
9958 
      (fname, ftype, fid) = iprot.readFieldBegin()
9959 
      if ftype == TType.STOP:
9960 
        break
9961 
      if fid == 1:
9962 
        if ftype == TType.LIST:
9963 
          self.order_ids = []
5031 varun.gupt 9964 
          (_etype171, _size168) = iprot.readListBegin()
9965 
          for _i172 in xrange(_size168):
9966 
            _elem173 = iprot.readI64();
9967 
            self.order_ids.append(_elem173)
4999 phani.kuma 9968 
          iprot.readListEnd()
9969 
        else:
9970 
          iprot.skip(ftype)
9971 
      else:
9972 
        iprot.skip(ftype)
9973 
      iprot.readFieldEnd()
9974 
    iprot.readStructEnd()
9975 
 
9976 
  def write(self, oprot):
9977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9979 
      return
9980 
    oprot.writeStructBegin('getOrderList_args')
9981 
    if self.order_ids is not None:
9982 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9983 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9984 
      for iter174 in self.order_ids:
9985 
        oprot.writeI64(iter174)
4999 phani.kuma 9986 
      oprot.writeListEnd()
9987 
      oprot.writeFieldEnd()
9988 
    oprot.writeFieldStop()
9989 
    oprot.writeStructEnd()
9990 
 
9991 
  def validate(self):
9992 
    return
9993 
 
9994 
 
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 
 
10006 
class getOrderList_result:
10007 
  """
10008 
  Attributes:
10009 
   - success
10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10014 
  )
10015 
 
10016 
  def __init__(self, success=None,):
10017 
    self.success = success
10018 
 
10019 
  def read(self, iprot):
10020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10022 
      return
10023 
    iprot.readStructBegin()
10024 
    while True:
10025 
      (fname, ftype, fid) = iprot.readFieldBegin()
10026 
      if ftype == TType.STOP:
10027 
        break
10028 
      if fid == 0:
10029 
        if ftype == TType.LIST:
10030 
          self.success = []
5031 varun.gupt 10031 
          (_etype178, _size175) = iprot.readListBegin()
10032 
          for _i179 in xrange(_size175):
10033 
            _elem180 = Order()
10034 
            _elem180.read(iprot)
10035 
            self.success.append(_elem180)
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_result')
10049 
    if self.success is not None:
10050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10052 
      for iter181 in self.success:
10053 
        iter181.write(oprot)
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 
 
5386 phani.kuma 10074 
class getOrderListForVendor_args:
10075 
  """
10076 
  Attributes:
10077 
   - order_ids
10078 
   - vendorId
10079 
  """
10080 
 
10081 
  thrift_spec = (
10082 
    None, # 0
10083 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10084 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10085 
  )
10086 
 
10087 
  def __init__(self, order_ids=None, vendorId=None,):
10088 
    self.order_ids = order_ids
10089 
    self.vendorId = vendorId
10090 
 
10091 
  def read(self, iprot):
10092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10094 
      return
10095 
    iprot.readStructBegin()
10096 
    while True:
10097 
      (fname, ftype, fid) = iprot.readFieldBegin()
10098 
      if ftype == TType.STOP:
10099 
        break
10100 
      if fid == 1:
10101 
        if ftype == TType.LIST:
10102 
          self.order_ids = []
10103 
          (_etype185, _size182) = iprot.readListBegin()
10104 
          for _i186 in xrange(_size182):
10105 
            _elem187 = iprot.readI64();
10106 
            self.order_ids.append(_elem187)
10107 
          iprot.readListEnd()
10108 
        else:
10109 
          iprot.skip(ftype)
10110 
      elif fid == 2:
10111 
        if ftype == TType.I64:
10112 
          self.vendorId = iprot.readI64();
10113 
        else:
10114 
          iprot.skip(ftype)
10115 
      else:
10116 
        iprot.skip(ftype)
10117 
      iprot.readFieldEnd()
10118 
    iprot.readStructEnd()
10119 
 
10120 
  def write(self, oprot):
10121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10123 
      return
10124 
    oprot.writeStructBegin('getOrderListForVendor_args')
10125 
    if self.order_ids is not None:
10126 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10127 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10128 
      for iter188 in self.order_ids:
10129 
        oprot.writeI64(iter188)
10130 
      oprot.writeListEnd()
10131 
      oprot.writeFieldEnd()
10132 
    if self.vendorId is not None:
10133 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10134 
      oprot.writeI64(self.vendorId)
10135 
      oprot.writeFieldEnd()
10136 
    oprot.writeFieldStop()
10137 
    oprot.writeStructEnd()
10138 
 
10139 
  def validate(self):
10140 
    return
10141 
 
10142 
 
10143 
  def __repr__(self):
10144 
    L = ['%s=%r' % (key, value)
10145 
      for key, value in self.__dict__.iteritems()]
10146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10147 
 
10148 
  def __eq__(self, other):
10149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10150 
 
10151 
  def __ne__(self, other):
10152 
    return not (self == other)
10153 
 
10154 
class getOrderListForVendor_result:
10155 
  """
10156 
  Attributes:
10157 
   - success
10158 
  """
10159 
 
10160 
  thrift_spec = (
10161 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10162 
  )
10163 
 
10164 
  def __init__(self, success=None,):
10165 
    self.success = success
10166 
 
10167 
  def read(self, iprot):
10168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10170 
      return
10171 
    iprot.readStructBegin()
10172 
    while True:
10173 
      (fname, ftype, fid) = iprot.readFieldBegin()
10174 
      if ftype == TType.STOP:
10175 
        break
10176 
      if fid == 0:
10177 
        if ftype == TType.LIST:
10178 
          self.success = []
10179 
          (_etype192, _size189) = iprot.readListBegin()
10180 
          for _i193 in xrange(_size189):
10181 
            _elem194 = Order()
10182 
            _elem194.read(iprot)
10183 
            self.success.append(_elem194)
10184 
          iprot.readListEnd()
10185 
        else:
10186 
          iprot.skip(ftype)
10187 
      else:
10188 
        iprot.skip(ftype)
10189 
      iprot.readFieldEnd()
10190 
    iprot.readStructEnd()
10191 
 
10192 
  def write(self, oprot):
10193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10195 
      return
10196 
    oprot.writeStructBegin('getOrderListForVendor_result')
10197 
    if self.success is not None:
10198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10199 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10200 
      for iter195 in self.success:
10201 
        iter195.write(oprot)
10202 
      oprot.writeListEnd()
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 
 
3064 chandransh 10222 
class getOrderForCustomer_args:
94 ashish 10223 
  """
10224 
  Attributes:
3064 chandransh 10225 
   - orderId
483 rajveer 10226 
   - customerId
94 ashish 10227 
  """
10228 
 
10229 
  thrift_spec = (
10230 
    None, # 0
3064 chandransh 10231 
    (1, TType.I64, 'orderId', None, None, ), # 1
10232 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10233 
  )
10234 
 
3064 chandransh 10235 
  def __init__(self, orderId=None, customerId=None,):
10236 
    self.orderId = orderId
483 rajveer 10237 
    self.customerId = customerId
94 ashish 10238 
 
10239 
  def read(self, iprot):
10240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10242 
      return
10243 
    iprot.readStructBegin()
10244 
    while True:
10245 
      (fname, ftype, fid) = iprot.readFieldBegin()
10246 
      if ftype == TType.STOP:
10247 
        break
10248 
      if fid == 1:
10249 
        if ftype == TType.I64:
3064 chandransh 10250 
          self.orderId = iprot.readI64();
94 ashish 10251 
        else:
10252 
          iprot.skip(ftype)
10253 
      elif fid == 2:
10254 
        if ftype == TType.I64:
3064 chandransh 10255 
          self.customerId = iprot.readI64();
94 ashish 10256 
        else:
10257 
          iprot.skip(ftype)
10258 
      else:
10259 
        iprot.skip(ftype)
10260 
      iprot.readFieldEnd()
10261 
    iprot.readStructEnd()
10262 
 
10263 
  def write(self, oprot):
10264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10266 
      return
3064 chandransh 10267 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10268 
    if self.orderId is not None:
3064 chandransh 10269 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10270 
      oprot.writeI64(self.orderId)
10271 
      oprot.writeFieldEnd()
3431 rajveer 10272 
    if self.customerId is not None:
3064 chandransh 10273 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10274 
      oprot.writeI64(self.customerId)
94 ashish 10275 
      oprot.writeFieldEnd()
10276 
    oprot.writeFieldStop()
10277 
    oprot.writeStructEnd()
10278 
 
3431 rajveer 10279 
  def validate(self):
10280 
    return
10281 
 
10282 
 
94 ashish 10283 
  def __repr__(self):
10284 
    L = ['%s=%r' % (key, value)
10285 
      for key, value in self.__dict__.iteritems()]
10286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10287 
 
10288 
  def __eq__(self, other):
10289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10290 
 
10291 
  def __ne__(self, other):
10292 
    return not (self == other)
10293 
 
3064 chandransh 10294 
class getOrderForCustomer_result:
94 ashish 10295 
  """
10296 
  Attributes:
10297 
   - success
10298 
   - ex
10299 
  """
10300 
 
10301 
  thrift_spec = (
3064 chandransh 10302 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10304 
  )
10305 
 
10306 
  def __init__(self, success=None, ex=None,):
10307 
    self.success = success
10308 
    self.ex = ex
10309 
 
10310 
  def read(self, iprot):
10311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10313 
      return
10314 
    iprot.readStructBegin()
10315 
    while True:
10316 
      (fname, ftype, fid) = iprot.readFieldBegin()
10317 
      if ftype == TType.STOP:
10318 
        break
10319 
      if fid == 0:
3064 chandransh 10320 
        if ftype == TType.STRUCT:
10321 
          self.success = Order()
10322 
          self.success.read(iprot)
94 ashish 10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      elif fid == 1:
10326 
        if ftype == TType.STRUCT:
10327 
          self.ex = TransactionServiceException()
10328 
          self.ex.read(iprot)
10329 
        else:
10330 
          iprot.skip(ftype)
10331 
      else:
10332 
        iprot.skip(ftype)
10333 
      iprot.readFieldEnd()
10334 
    iprot.readStructEnd()
10335 
 
10336 
  def write(self, oprot):
10337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10339 
      return
3064 chandransh 10340 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10341 
    if self.success is not None:
3064 chandransh 10342 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10343 
      self.success.write(oprot)
94 ashish 10344 
      oprot.writeFieldEnd()
3431 rajveer 10345 
    if self.ex is not None:
94 ashish 10346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10347 
      self.ex.write(oprot)
10348 
      oprot.writeFieldEnd()
10349 
    oprot.writeFieldStop()
10350 
    oprot.writeStructEnd()
10351 
 
3431 rajveer 10352 
  def validate(self):
10353 
    return
10354 
 
10355 
 
94 ashish 10356 
  def __repr__(self):
10357 
    L = ['%s=%r' % (key, value)
10358 
      for key, value in self.__dict__.iteritems()]
10359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10360 
 
10361 
  def __eq__(self, other):
10362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10363 
 
10364 
  def __ne__(self, other):
10365 
    return not (self == other)
10366 
 
3064 chandransh 10367 
class getAlerts_args:
94 ashish 10368 
  """
10369 
  Attributes:
4394 rajveer 10370 
   - type
4444 rajveer 10371 
   - warehouseId
4394 rajveer 10372 
   - status
10373 
   - timestamp
94 ashish 10374 
  """
10375 
 
10376 
  thrift_spec = (
10377 
    None, # 0
4394 rajveer 10378 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10379 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10380 
    (3, TType.I64, 'status', None, None, ), # 3
10381 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10382 
  )
10383 
 
4444 rajveer 10384 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10385 
    self.type = type
4444 rajveer 10386 
    self.warehouseId = warehouseId
4394 rajveer 10387 
    self.status = status
10388 
    self.timestamp = timestamp
94 ashish 10389 
 
10390 
  def read(self, iprot):
10391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10393 
      return
10394 
    iprot.readStructBegin()
10395 
    while True:
10396 
      (fname, ftype, fid) = iprot.readFieldBegin()
10397 
      if ftype == TType.STOP:
10398 
        break
10399 
      if fid == 1:
3064 chandransh 10400 
        if ftype == TType.I64:
4394 rajveer 10401 
          self.type = iprot.readI64();
94 ashish 10402 
        else:
10403 
          iprot.skip(ftype)
3064 chandransh 10404 
      elif fid == 2:
4394 rajveer 10405 
        if ftype == TType.I64:
4444 rajveer 10406 
          self.warehouseId = iprot.readI64();
3064 chandransh 10407 
        else:
10408 
          iprot.skip(ftype)
4394 rajveer 10409 
      elif fid == 3:
10410 
        if ftype == TType.I64:
4444 rajveer 10411 
          self.status = iprot.readI64();
10412 
        else:
10413 
          iprot.skip(ftype)
10414 
      elif fid == 4:
10415 
        if ftype == TType.I64:
4394 rajveer 10416 
          self.timestamp = iprot.readI64();
10417 
        else:
10418 
          iprot.skip(ftype)
94 ashish 10419 
      else:
10420 
        iprot.skip(ftype)
10421 
      iprot.readFieldEnd()
10422 
    iprot.readStructEnd()
10423 
 
10424 
  def write(self, oprot):
10425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10427 
      return
3064 chandransh 10428 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10429 
    if self.type is not None:
10430 
      oprot.writeFieldBegin('type', TType.I64, 1)
10431 
      oprot.writeI64(self.type)
94 ashish 10432 
      oprot.writeFieldEnd()
4444 rajveer 10433 
    if self.warehouseId is not None:
10434 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10435 
      oprot.writeI64(self.warehouseId)
10436 
      oprot.writeFieldEnd()
4394 rajveer 10437 
    if self.status is not None:
4444 rajveer 10438 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10439 
      oprot.writeI64(self.status)
3064 chandransh 10440 
      oprot.writeFieldEnd()
4394 rajveer 10441 
    if self.timestamp is not None:
4444 rajveer 10442 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10443 
      oprot.writeI64(self.timestamp)
10444 
      oprot.writeFieldEnd()
94 ashish 10445 
    oprot.writeFieldStop()
10446 
    oprot.writeStructEnd()
10447 
 
3431 rajveer 10448 
  def validate(self):
10449 
    return
10450 
 
10451 
 
94 ashish 10452 
  def __repr__(self):
10453 
    L = ['%s=%r' % (key, value)
10454 
      for key, value in self.__dict__.iteritems()]
10455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10456 
 
10457 
  def __eq__(self, other):
10458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10459 
 
10460 
  def __ne__(self, other):
10461 
    return not (self == other)
10462 
 
3064 chandransh 10463 
class getAlerts_result:
94 ashish 10464 
  """
10465 
  Attributes:
10466 
   - success
10467 
  """
10468 
 
10469 
  thrift_spec = (
3064 chandransh 10470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10471 
  )
10472 
 
3064 chandransh 10473 
  def __init__(self, success=None,):
94 ashish 10474 
    self.success = success
10475 
 
10476 
  def read(self, iprot):
10477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10479 
      return
10480 
    iprot.readStructBegin()
10481 
    while True:
10482 
      (fname, ftype, fid) = iprot.readFieldBegin()
10483 
      if ftype == TType.STOP:
10484 
        break
10485 
      if fid == 0:
3064 chandransh 10486 
        if ftype == TType.LIST:
10487 
          self.success = []
5386 phani.kuma 10488 
          (_etype199, _size196) = iprot.readListBegin()
10489 
          for _i200 in xrange(_size196):
10490 
            _elem201 = Alert()
10491 
            _elem201.read(iprot)
10492 
            self.success.append(_elem201)
3064 chandransh 10493 
          iprot.readListEnd()
94 ashish 10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      else:
10497 
        iprot.skip(ftype)
10498 
      iprot.readFieldEnd()
10499 
    iprot.readStructEnd()
10500 
 
10501 
  def write(self, oprot):
10502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10504 
      return
3064 chandransh 10505 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10506 
    if self.success is not None:
3064 chandransh 10507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 10509 
      for iter202 in self.success:
10510 
        iter202.write(oprot)
3064 chandransh 10511 
      oprot.writeListEnd()
94 ashish 10512 
      oprot.writeFieldEnd()
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 
 
4394 rajveer 10531 
class addAlert_args:
94 ashish 10532 
  """
10533 
  Attributes:
3064 chandransh 10534 
   - type
4444 rajveer 10535 
   - warehouseId
4394 rajveer 10536 
   - description
94 ashish 10537 
  """
10538 
 
10539 
  thrift_spec = (
10540 
    None, # 0
4394 rajveer 10541 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10542 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10543 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10544 
  )
10545 
 
4444 rajveer 10546 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10547 
    self.type = type
4444 rajveer 10548 
    self.warehouseId = warehouseId
4394 rajveer 10549 
    self.description = description
94 ashish 10550 
 
10551 
  def read(self, iprot):
10552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10554 
      return
10555 
    iprot.readStructBegin()
10556 
    while True:
10557 
      (fname, ftype, fid) = iprot.readFieldBegin()
10558 
      if ftype == TType.STOP:
10559 
        break
10560 
      if fid == 1:
10561 
        if ftype == TType.I64:
4394 rajveer 10562 
          self.type = iprot.readI64();
94 ashish 10563 
        else:
10564 
          iprot.skip(ftype)
3064 chandransh 10565 
      elif fid == 2:
4444 rajveer 10566 
        if ftype == TType.I64:
10567 
          self.warehouseId = iprot.readI64();
10568 
        else:
10569 
          iprot.skip(ftype)
10570 
      elif fid == 3:
3064 chandransh 10571 
        if ftype == TType.STRING:
4394 rajveer 10572 
          self.description = iprot.readString();
3064 chandransh 10573 
        else:
10574 
          iprot.skip(ftype)
94 ashish 10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
4394 rajveer 10584 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10585 
    if self.type is not None:
4394 rajveer 10586 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10587 
      oprot.writeI64(self.type)
10588 
      oprot.writeFieldEnd()
4444 rajveer 10589 
    if self.warehouseId is not None:
10590 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10591 
      oprot.writeI64(self.warehouseId)
10592 
      oprot.writeFieldEnd()
4394 rajveer 10593 
    if self.description is not None:
4444 rajveer 10594 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10595 
      oprot.writeString(self.description)
3064 chandransh 10596 
      oprot.writeFieldEnd()
94 ashish 10597 
    oprot.writeFieldStop()
10598 
    oprot.writeStructEnd()
10599 
 
3431 rajveer 10600 
  def validate(self):
10601 
    return
10602 
 
10603 
 
94 ashish 10604 
  def __repr__(self):
10605 
    L = ['%s=%r' % (key, value)
10606 
      for key, value in self.__dict__.iteritems()]
10607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10608 
 
10609 
  def __eq__(self, other):
10610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10611 
 
10612 
  def __ne__(self, other):
10613 
    return not (self == other)
10614 
 
4394 rajveer 10615 
class addAlert_result:
3064 chandransh 10616 
 
10617 
  thrift_spec = (
10618 
  )
10619 
 
10620 
  def read(self, iprot):
10621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10623 
      return
10624 
    iprot.readStructBegin()
10625 
    while True:
10626 
      (fname, ftype, fid) = iprot.readFieldBegin()
10627 
      if ftype == TType.STOP:
10628 
        break
10629 
      else:
10630 
        iprot.skip(ftype)
10631 
      iprot.readFieldEnd()
10632 
    iprot.readStructEnd()
10633 
 
10634 
  def write(self, oprot):
10635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10637 
      return
4394 rajveer 10638 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10639 
    oprot.writeFieldStop()
10640 
    oprot.writeStructEnd()
10641 
 
3431 rajveer 10642 
  def validate(self):
10643 
    return
10644 
 
10645 
 
3064 chandransh 10646 
  def __repr__(self):
10647 
    L = ['%s=%r' % (key, value)
10648 
      for key, value in self.__dict__.iteritems()]
10649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10650 
 
10651 
  def __eq__(self, other):
10652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10653 
 
10654 
  def __ne__(self, other):
10655 
    return not (self == other)
10656 
 
4444 rajveer 10657 
class markAlertsAsSeen_args:
10658 
  """
10659 
  Attributes:
10660 
   - warehouseId
10661 
  """
10662 
 
10663 
  thrift_spec = (
10664 
    None, # 0
10665 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10666 
  )
10667 
 
10668 
  def __init__(self, warehouseId=None,):
10669 
    self.warehouseId = warehouseId
10670 
 
10671 
  def read(self, iprot):
10672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10674 
      return
10675 
    iprot.readStructBegin()
10676 
    while True:
10677 
      (fname, ftype, fid) = iprot.readFieldBegin()
10678 
      if ftype == TType.STOP:
10679 
        break
10680 
      if fid == 1:
10681 
        if ftype == TType.I64:
10682 
          self.warehouseId = iprot.readI64();
10683 
        else:
10684 
          iprot.skip(ftype)
10685 
      else:
10686 
        iprot.skip(ftype)
10687 
      iprot.readFieldEnd()
10688 
    iprot.readStructEnd()
10689 
 
10690 
  def write(self, oprot):
10691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10693 
      return
10694 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10695 
    if self.warehouseId is not None:
10696 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10697 
      oprot.writeI64(self.warehouseId)
10698 
      oprot.writeFieldEnd()
10699 
    oprot.writeFieldStop()
10700 
    oprot.writeStructEnd()
10701 
 
10702 
  def validate(self):
10703 
    return
10704 
 
10705 
 
10706 
  def __repr__(self):
10707 
    L = ['%s=%r' % (key, value)
10708 
      for key, value in self.__dict__.iteritems()]
10709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10710 
 
10711 
  def __eq__(self, other):
10712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10713 
 
10714 
  def __ne__(self, other):
10715 
    return not (self == other)
10716 
 
10717 
class markAlertsAsSeen_result:
10718 
 
10719 
  thrift_spec = (
10720 
  )
10721 
 
10722 
  def read(self, iprot):
10723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10725 
      return
10726 
    iprot.readStructBegin()
10727 
    while True:
10728 
      (fname, ftype, fid) = iprot.readFieldBegin()
10729 
      if ftype == TType.STOP:
10730 
        break
10731 
      else:
10732 
        iprot.skip(ftype)
10733 
      iprot.readFieldEnd()
10734 
    iprot.readStructEnd()
10735 
 
10736 
  def write(self, oprot):
10737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10739 
      return
10740 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10741 
    oprot.writeFieldStop()
10742 
    oprot.writeStructEnd()
10743 
 
10744 
  def validate(self):
10745 
    return
10746 
 
10747 
 
10748 
  def __repr__(self):
10749 
    L = ['%s=%r' % (key, value)
10750 
      for key, value in self.__dict__.iteritems()]
10751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10752 
 
10753 
  def __eq__(self, other):
10754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10755 
 
10756 
  def __ne__(self, other):
10757 
    return not (self == other)
10758 
 
3064 chandransh 10759 
class getValidOrderCount_args:
10760 
 
10761 
  thrift_spec = (
10762 
  )
10763 
 
10764 
  def read(self, iprot):
10765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10767 
      return
10768 
    iprot.readStructBegin()
10769 
    while True:
10770 
      (fname, ftype, fid) = iprot.readFieldBegin()
10771 
      if ftype == TType.STOP:
10772 
        break
10773 
      else:
10774 
        iprot.skip(ftype)
10775 
      iprot.readFieldEnd()
10776 
    iprot.readStructEnd()
10777 
 
10778 
  def write(self, oprot):
10779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10781 
      return
10782 
    oprot.writeStructBegin('getValidOrderCount_args')
10783 
    oprot.writeFieldStop()
10784 
    oprot.writeStructEnd()
10785 
 
3431 rajveer 10786 
  def validate(self):
10787 
    return
10788 
 
10789 
 
3064 chandransh 10790 
  def __repr__(self):
10791 
    L = ['%s=%r' % (key, value)
10792 
      for key, value in self.__dict__.iteritems()]
10793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10794 
 
10795 
  def __eq__(self, other):
10796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10797 
 
10798 
  def __ne__(self, other):
10799 
    return not (self == other)
10800 
 
10801 
class getValidOrderCount_result:
94 ashish 10802 
  """
10803 
  Attributes:
10804 
   - success
10805 
  """
10806 
 
10807 
  thrift_spec = (
3064 chandransh 10808 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10809 
  )
10810 
 
3064 chandransh 10811 
  def __init__(self, success=None,):
94 ashish 10812 
    self.success = success
10813 
 
10814 
  def read(self, iprot):
10815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10817 
      return
10818 
    iprot.readStructBegin()
10819 
    while True:
10820 
      (fname, ftype, fid) = iprot.readFieldBegin()
10821 
      if ftype == TType.STOP:
10822 
        break
10823 
      if fid == 0:
3064 chandransh 10824 
        if ftype == TType.I64:
10825 
          self.success = iprot.readI64();
94 ashish 10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      else:
10829 
        iprot.skip(ftype)
10830 
      iprot.readFieldEnd()
10831 
    iprot.readStructEnd()
10832 
 
10833 
  def write(self, oprot):
10834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10836 
      return
3064 chandransh 10837 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10838 
    if self.success is not None:
3064 chandransh 10839 
      oprot.writeFieldBegin('success', TType.I64, 0)
10840 
      oprot.writeI64(self.success)
94 ashish 10841 
      oprot.writeFieldEnd()
10842 
    oprot.writeFieldStop()
10843 
    oprot.writeStructEnd()
10844 
 
3431 rajveer 10845 
  def validate(self):
10846 
    return
10847 
 
10848 
 
94 ashish 10849 
  def __repr__(self):
10850 
    L = ['%s=%r' % (key, value)
10851 
      for key, value in self.__dict__.iteritems()]
10852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10853 
 
10854 
  def __eq__(self, other):
10855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10856 
 
10857 
  def __ne__(self, other):
10858 
    return not (self == other)
10859 
 
3064 chandransh 10860 
class getNoOfCustomersWithSuccessfulTransaction_args:
10861 
 
10862 
  thrift_spec = (
10863 
  )
10864 
 
10865 
  def read(self, iprot):
10866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10868 
      return
10869 
    iprot.readStructBegin()
10870 
    while True:
10871 
      (fname, ftype, fid) = iprot.readFieldBegin()
10872 
      if ftype == TType.STOP:
10873 
        break
10874 
      else:
10875 
        iprot.skip(ftype)
10876 
      iprot.readFieldEnd()
10877 
    iprot.readStructEnd()
10878 
 
10879 
  def write(self, oprot):
10880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10882 
      return
10883 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10884 
    oprot.writeFieldStop()
10885 
    oprot.writeStructEnd()
10886 
 
3431 rajveer 10887 
  def validate(self):
10888 
    return
10889 
 
10890 
 
3064 chandransh 10891 
  def __repr__(self):
10892 
    L = ['%s=%r' % (key, value)
10893 
      for key, value in self.__dict__.iteritems()]
10894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10895 
 
10896 
  def __eq__(self, other):
10897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10898 
 
10899 
  def __ne__(self, other):
10900 
    return not (self == other)
10901 
 
10902 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10903 
  """
10904 
  Attributes:
3064 chandransh 10905 
   - success
94 ashish 10906 
  """
10907 
 
10908 
  thrift_spec = (
3064 chandransh 10909 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10910 
  )
10911 
 
3064 chandransh 10912 
  def __init__(self, success=None,):
10913 
    self.success = success
94 ashish 10914 
 
10915 
  def read(self, iprot):
10916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10918 
      return
10919 
    iprot.readStructBegin()
10920 
    while True:
10921 
      (fname, ftype, fid) = iprot.readFieldBegin()
10922 
      if ftype == TType.STOP:
10923 
        break
3064 chandransh 10924 
      if fid == 0:
94 ashish 10925 
        if ftype == TType.I64:
3064 chandransh 10926 
          self.success = iprot.readI64();
94 ashish 10927 
        else:
10928 
          iprot.skip(ftype)
10929 
      else:
10930 
        iprot.skip(ftype)
10931 
      iprot.readFieldEnd()
10932 
    iprot.readStructEnd()
10933 
 
10934 
  def write(self, oprot):
10935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10937 
      return
3064 chandransh 10938 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10939 
    if self.success is not None:
3064 chandransh 10940 
      oprot.writeFieldBegin('success', TType.I64, 0)
10941 
      oprot.writeI64(self.success)
94 ashish 10942 
      oprot.writeFieldEnd()
10943 
    oprot.writeFieldStop()
10944 
    oprot.writeStructEnd()
10945 
 
3431 rajveer 10946 
  def validate(self):
10947 
    return
10948 
 
10949 
 
94 ashish 10950 
  def __repr__(self):
10951 
    L = ['%s=%r' % (key, value)
10952 
      for key, value in self.__dict__.iteritems()]
10953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10954 
 
10955 
  def __eq__(self, other):
10956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10957 
 
10958 
  def __ne__(self, other):
10959 
    return not (self == other)
10960 
 
3064 chandransh 10961 
class getValidOrdersAmountRange_args:
10962 
 
10963 
  thrift_spec = (
10964 
  )
10965 
 
10966 
  def read(self, iprot):
10967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10969 
      return
10970 
    iprot.readStructBegin()
10971 
    while True:
10972 
      (fname, ftype, fid) = iprot.readFieldBegin()
10973 
      if ftype == TType.STOP:
10974 
        break
10975 
      else:
10976 
        iprot.skip(ftype)
10977 
      iprot.readFieldEnd()
10978 
    iprot.readStructEnd()
10979 
 
10980 
  def write(self, oprot):
10981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10983 
      return
10984 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10985 
    oprot.writeFieldStop()
10986 
    oprot.writeStructEnd()
10987 
 
3431 rajveer 10988 
  def validate(self):
10989 
    return
10990 
 
10991 
 
3064 chandransh 10992 
  def __repr__(self):
10993 
    L = ['%s=%r' % (key, value)
10994 
      for key, value in self.__dict__.iteritems()]
10995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10996 
 
10997 
  def __eq__(self, other):
10998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10999 
 
11000 
  def __ne__(self, other):
11001 
    return not (self == other)
11002 
 
11003 
class getValidOrdersAmountRange_result:
94 ashish 11004 
  """
11005 
  Attributes:
11006 
   - success
11007 
  """
11008 
 
11009 
  thrift_spec = (
3064 chandransh 11010 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11011 
  )
11012 
 
3064 chandransh 11013 
  def __init__(self, success=None,):
94 ashish 11014 
    self.success = success
11015 
 
11016 
  def read(self, iprot):
11017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11019 
      return
11020 
    iprot.readStructBegin()
11021 
    while True:
11022 
      (fname, ftype, fid) = iprot.readFieldBegin()
11023 
      if ftype == TType.STOP:
11024 
        break
11025 
      if fid == 0:
483 rajveer 11026 
        if ftype == TType.LIST:
11027 
          self.success = []
5386 phani.kuma 11028 
          (_etype206, _size203) = iprot.readListBegin()
11029 
          for _i207 in xrange(_size203):
11030 
            _elem208 = iprot.readDouble();
11031 
            self.success.append(_elem208)
483 rajveer 11032 
          iprot.readListEnd()
94 ashish 11033 
        else:
11034 
          iprot.skip(ftype)
11035 
      else:
11036 
        iprot.skip(ftype)
11037 
      iprot.readFieldEnd()
11038 
    iprot.readStructEnd()
11039 
 
11040 
  def write(self, oprot):
11041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11043 
      return
3064 chandransh 11044 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11045 
    if self.success is not None:
483 rajveer 11046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11047 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11048 
      for iter209 in self.success:
11049 
        oprot.writeDouble(iter209)
483 rajveer 11050 
      oprot.writeListEnd()
94 ashish 11051 
      oprot.writeFieldEnd()
11052 
    oprot.writeFieldStop()
11053 
    oprot.writeStructEnd()
11054 
 
3431 rajveer 11055 
  def validate(self):
11056 
    return
11057 
 
11058 
 
94 ashish 11059 
  def __repr__(self):
11060 
    L = ['%s=%r' % (key, value)
11061 
      for key, value in self.__dict__.iteritems()]
11062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11063 
 
11064 
  def __eq__(self, other):
11065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11066 
 
11067 
  def __ne__(self, other):
11068 
    return not (self == other)
11069 
 
3064 chandransh 11070 
class getValidOrders_args:
1528 ankur.sing 11071 
  """
11072 
  Attributes:
3064 chandransh 11073 
   - limit
1528 ankur.sing 11074 
  """
11075 
 
11076 
  thrift_spec = (
11077 
    None, # 0
3064 chandransh 11078 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11079 
  )
11080 
 
3064 chandransh 11081 
  def __init__(self, limit=None,):
11082 
    self.limit = limit
1528 ankur.sing 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 == 1:
11094 
        if ftype == TType.I64:
3064 chandransh 11095 
          self.limit = iprot.readI64();
1528 ankur.sing 11096 
        else:
11097 
          iprot.skip(ftype)
11098 
      else:
11099 
        iprot.skip(ftype)
11100 
      iprot.readFieldEnd()
11101 
    iprot.readStructEnd()
11102 
 
11103 
  def write(self, oprot):
11104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11106 
      return
3064 chandransh 11107 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11108 
    if self.limit is not None:
3064 chandransh 11109 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11110 
      oprot.writeI64(self.limit)
1528 ankur.sing 11111 
      oprot.writeFieldEnd()
11112 
    oprot.writeFieldStop()
11113 
    oprot.writeStructEnd()
11114 
 
3431 rajveer 11115 
  def validate(self):
11116 
    return
11117 
 
11118 
 
1528 ankur.sing 11119 
  def __repr__(self):
11120 
    L = ['%s=%r' % (key, value)
11121 
      for key, value in self.__dict__.iteritems()]
11122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11123 
 
11124 
  def __eq__(self, other):
11125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11126 
 
11127 
  def __ne__(self, other):
11128 
    return not (self == other)
11129 
 
3064 chandransh 11130 
class getValidOrders_result:
1528 ankur.sing 11131 
  """
11132 
  Attributes:
11133 
   - success
11134 
  """
11135 
 
11136 
  thrift_spec = (
3064 chandransh 11137 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11138 
  )
11139 
 
3064 chandransh 11140 
  def __init__(self, success=None,):
1528 ankur.sing 11141 
    self.success = success
11142 
 
11143 
  def read(self, iprot):
11144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11146 
      return
11147 
    iprot.readStructBegin()
11148 
    while True:
11149 
      (fname, ftype, fid) = iprot.readFieldBegin()
11150 
      if ftype == TType.STOP:
11151 
        break
11152 
      if fid == 0:
3064 chandransh 11153 
        if ftype == TType.LIST:
11154 
          self.success = []
5386 phani.kuma 11155 
          (_etype213, _size210) = iprot.readListBegin()
11156 
          for _i214 in xrange(_size210):
11157 
            _elem215 = Order()
11158 
            _elem215.read(iprot)
11159 
            self.success.append(_elem215)
3064 chandransh 11160 
          iprot.readListEnd()
1528 ankur.sing 11161 
        else:
11162 
          iprot.skip(ftype)
11163 
      else:
11164 
        iprot.skip(ftype)
11165 
      iprot.readFieldEnd()
11166 
    iprot.readStructEnd()
11167 
 
11168 
  def write(self, oprot):
11169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11171 
      return
3064 chandransh 11172 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11173 
    if self.success is not None:
3064 chandransh 11174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11176 
      for iter216 in self.success:
11177 
        iter216.write(oprot)
3064 chandransh 11178 
      oprot.writeListEnd()
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 
 
1220 chandransh 11198 
class batchOrders_args:
11199 
  """
11200 
  Attributes:
11201 
   - warehouseId
11202 
  """
11203 
 
11204 
  thrift_spec = (
11205 
    None, # 0
11206 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11207 
  )
11208 
 
11209 
  def __init__(self, warehouseId=None,):
11210 
    self.warehouseId = warehouseId
11211 
 
11212 
  def read(self, iprot):
11213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11215 
      return
11216 
    iprot.readStructBegin()
11217 
    while True:
11218 
      (fname, ftype, fid) = iprot.readFieldBegin()
11219 
      if ftype == TType.STOP:
11220 
        break
11221 
      if fid == 1:
11222 
        if ftype == TType.I64:
11223 
          self.warehouseId = iprot.readI64();
11224 
        else:
11225 
          iprot.skip(ftype)
11226 
      else:
11227 
        iprot.skip(ftype)
11228 
      iprot.readFieldEnd()
11229 
    iprot.readStructEnd()
11230 
 
11231 
  def write(self, oprot):
11232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11234 
      return
11235 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11236 
    if self.warehouseId is not None:
1220 chandransh 11237 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11238 
      oprot.writeI64(self.warehouseId)
11239 
      oprot.writeFieldEnd()
11240 
    oprot.writeFieldStop()
11241 
    oprot.writeStructEnd()
11242 
 
3431 rajveer 11243 
  def validate(self):
11244 
    return
11245 
 
11246 
 
1220 chandransh 11247 
  def __repr__(self):
11248 
    L = ['%s=%r' % (key, value)
11249 
      for key, value in self.__dict__.iteritems()]
11250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11251 
 
11252 
  def __eq__(self, other):
11253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11254 
 
11255 
  def __ne__(self, other):
11256 
    return not (self == other)
11257 
 
11258 
class batchOrders_result:
11259 
  """
11260 
  Attributes:
11261 
   - success
11262 
   - ex
11263 
  """
11264 
 
11265 
  thrift_spec = (
11266 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11268 
  )
11269 
 
11270 
  def __init__(self, success=None, ex=None,):
11271 
    self.success = success
11272 
    self.ex = ex
11273 
 
11274 
  def read(self, iprot):
11275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11277 
      return
11278 
    iprot.readStructBegin()
11279 
    while True:
11280 
      (fname, ftype, fid) = iprot.readFieldBegin()
11281 
      if ftype == TType.STOP:
11282 
        break
11283 
      if fid == 0:
11284 
        if ftype == TType.LIST:
11285 
          self.success = []
5386 phani.kuma 11286 
          (_etype220, _size217) = iprot.readListBegin()
11287 
          for _i221 in xrange(_size217):
11288 
            _elem222 = Order()
11289 
            _elem222.read(iprot)
11290 
            self.success.append(_elem222)
1220 chandransh 11291 
          iprot.readListEnd()
11292 
        else:
11293 
          iprot.skip(ftype)
11294 
      elif fid == 1:
11295 
        if ftype == TType.STRUCT:
11296 
          self.ex = TransactionServiceException()
11297 
          self.ex.read(iprot)
11298 
        else:
11299 
          iprot.skip(ftype)
11300 
      else:
11301 
        iprot.skip(ftype)
11302 
      iprot.readFieldEnd()
11303 
    iprot.readStructEnd()
11304 
 
11305 
  def write(self, oprot):
11306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11308 
      return
11309 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11310 
    if self.success is not None:
1220 chandransh 11311 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11312 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11313 
      for iter223 in self.success:
11314 
        iter223.write(oprot)
1220 chandransh 11315 
      oprot.writeListEnd()
11316 
      oprot.writeFieldEnd()
3431 rajveer 11317 
    if self.ex is not None:
1220 chandransh 11318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11319 
      self.ex.write(oprot)
11320 
      oprot.writeFieldEnd()
11321 
    oprot.writeFieldStop()
11322 
    oprot.writeStructEnd()
11323 
 
3431 rajveer 11324 
  def validate(self):
11325 
    return
11326 
 
11327 
 
1220 chandransh 11328 
  def __repr__(self):
11329 
    L = ['%s=%r' % (key, value)
11330 
      for key, value in self.__dict__.iteritems()]
11331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11332 
 
11333 
  def __eq__(self, other):
11334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11335 
 
11336 
  def __ne__(self, other):
11337 
    return not (self == other)
11338 
 
1208 chandransh 11339 
class markOrderAsOutOfStock_args:
11340 
  """
11341 
  Attributes:
11342 
   - orderId
11343 
  """
11344 
 
11345 
  thrift_spec = (
11346 
    None, # 0
11347 
    (1, TType.I64, 'orderId', None, None, ), # 1
11348 
  )
11349 
 
11350 
  def __init__(self, orderId=None,):
11351 
    self.orderId = orderId
11352 
 
11353 
  def read(self, iprot):
11354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11356 
      return
11357 
    iprot.readStructBegin()
11358 
    while True:
11359 
      (fname, ftype, fid) = iprot.readFieldBegin()
11360 
      if ftype == TType.STOP:
11361 
        break
11362 
      if fid == 1:
11363 
        if ftype == TType.I64:
11364 
          self.orderId = iprot.readI64();
11365 
        else:
11366 
          iprot.skip(ftype)
11367 
      else:
11368 
        iprot.skip(ftype)
11369 
      iprot.readFieldEnd()
11370 
    iprot.readStructEnd()
11371 
 
11372 
  def write(self, oprot):
11373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11375 
      return
11376 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11377 
    if self.orderId is not None:
1208 chandransh 11378 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11379 
      oprot.writeI64(self.orderId)
11380 
      oprot.writeFieldEnd()
11381 
    oprot.writeFieldStop()
11382 
    oprot.writeStructEnd()
11383 
 
3431 rajveer 11384 
  def validate(self):
11385 
    return
11386 
 
11387 
 
1208 chandransh 11388 
  def __repr__(self):
11389 
    L = ['%s=%r' % (key, value)
11390 
      for key, value in self.__dict__.iteritems()]
11391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11392 
 
11393 
  def __eq__(self, other):
11394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11395 
 
11396 
  def __ne__(self, other):
11397 
    return not (self == other)
11398 
 
11399 
class markOrderAsOutOfStock_result:
11400 
  """
11401 
  Attributes:
11402 
   - success
11403 
   - ex
11404 
  """
11405 
 
11406 
  thrift_spec = (
11407 
    (0, TType.BOOL, 'success', None, None, ), # 0
11408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11409 
  )
11410 
 
11411 
  def __init__(self, success=None, ex=None,):
11412 
    self.success = success
11413 
    self.ex = ex
11414 
 
11415 
  def read(self, iprot):
11416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11418 
      return
11419 
    iprot.readStructBegin()
11420 
    while True:
11421 
      (fname, ftype, fid) = iprot.readFieldBegin()
11422 
      if ftype == TType.STOP:
11423 
        break
11424 
      if fid == 0:
11425 
        if ftype == TType.BOOL:
11426 
          self.success = iprot.readBool();
11427 
        else:
11428 
          iprot.skip(ftype)
11429 
      elif fid == 1:
11430 
        if ftype == TType.STRUCT:
11431 
          self.ex = TransactionServiceException()
11432 
          self.ex.read(iprot)
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_result')
3431 rajveer 11445 
    if self.success is not None:
1208 chandransh 11446 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11447 
      oprot.writeBool(self.success)
11448 
      oprot.writeFieldEnd()
3431 rajveer 11449 
    if self.ex is not None:
1208 chandransh 11450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11451 
      self.ex.write(oprot)
11452 
      oprot.writeFieldEnd()
11453 
    oprot.writeFieldStop()
11454 
    oprot.writeStructEnd()
11455 
 
3431 rajveer 11456 
  def validate(self):
11457 
    return
11458 
 
11459 
 
1208 chandransh 11460 
  def __repr__(self):
11461 
    L = ['%s=%r' % (key, value)
11462 
      for key, value in self.__dict__.iteritems()]
11463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11464 
 
11465 
  def __eq__(self, other):
11466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11467 
 
11468 
  def __ne__(self, other):
11469 
    return not (self == other)
11470 
 
3064 chandransh 11471 
class verifyOrder_args:
759 chandransh 11472 
  """
11473 
  Attributes:
3064 chandransh 11474 
   - orderId
759 chandransh 11475 
  """
11476 
 
11477 
  thrift_spec = (
11478 
    None, # 0
3064 chandransh 11479 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11480 
  )
11481 
 
3064 chandransh 11482 
  def __init__(self, orderId=None,):
11483 
    self.orderId = orderId
759 chandransh 11484 
 
11485 
  def read(self, iprot):
11486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11488 
      return
11489 
    iprot.readStructBegin()
11490 
    while True:
11491 
      (fname, ftype, fid) = iprot.readFieldBegin()
11492 
      if ftype == TType.STOP:
11493 
        break
11494 
      if fid == 1:
11495 
        if ftype == TType.I64:
3064 chandransh 11496 
          self.orderId = iprot.readI64();
759 chandransh 11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      else:
11500 
        iprot.skip(ftype)
11501 
      iprot.readFieldEnd()
11502 
    iprot.readStructEnd()
11503 
 
11504 
  def write(self, oprot):
11505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11507 
      return
3064 chandransh 11508 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11509 
    if self.orderId is not None:
3064 chandransh 11510 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11511 
      oprot.writeI64(self.orderId)
759 chandransh 11512 
      oprot.writeFieldEnd()
11513 
    oprot.writeFieldStop()
11514 
    oprot.writeStructEnd()
11515 
 
3431 rajveer 11516 
  def validate(self):
11517 
    return
11518 
 
11519 
 
759 chandransh 11520 
  def __repr__(self):
11521 
    L = ['%s=%r' % (key, value)
11522 
      for key, value in self.__dict__.iteritems()]
11523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11524 
 
11525 
  def __eq__(self, other):
11526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11527 
 
11528 
  def __ne__(self, other):
11529 
    return not (self == other)
11530 
 
3064 chandransh 11531 
class verifyOrder_result:
759 chandransh 11532 
  """
11533 
  Attributes:
11534 
   - success
11535 
   - ex
11536 
  """
11537 
 
11538 
  thrift_spec = (
11539 
    (0, TType.BOOL, 'success', None, None, ), # 0
11540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11541 
  )
11542 
 
11543 
  def __init__(self, success=None, ex=None,):
11544 
    self.success = success
11545 
    self.ex = ex
11546 
 
11547 
  def read(self, iprot):
11548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11550 
      return
11551 
    iprot.readStructBegin()
11552 
    while True:
11553 
      (fname, ftype, fid) = iprot.readFieldBegin()
11554 
      if ftype == TType.STOP:
11555 
        break
11556 
      if fid == 0:
11557 
        if ftype == TType.BOOL:
11558 
          self.success = iprot.readBool();
11559 
        else:
11560 
          iprot.skip(ftype)
11561 
      elif fid == 1:
11562 
        if ftype == TType.STRUCT:
11563 
          self.ex = TransactionServiceException()
11564 
          self.ex.read(iprot)
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_result')
3431 rajveer 11577 
    if self.success is not None:
759 chandransh 11578 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11579 
      oprot.writeBool(self.success)
11580 
      oprot.writeFieldEnd()
3431 rajveer 11581 
    if self.ex is not None:
759 chandransh 11582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11583 
      self.ex.write(oprot)
11584 
      oprot.writeFieldEnd()
11585 
    oprot.writeFieldStop()
11586 
    oprot.writeStructEnd()
11587 
 
3431 rajveer 11588 
  def validate(self):
11589 
    return
11590 
 
11591 
 
759 chandransh 11592 
  def __repr__(self):
11593 
    L = ['%s=%r' % (key, value)
11594 
      for key, value in self.__dict__.iteritems()]
11595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11596 
 
11597 
  def __eq__(self, other):
11598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11599 
 
11600 
  def __ne__(self, other):
11601 
    return not (self == other)
11602 
 
3064 chandransh 11603 
class acceptOrder_args:
1113 chandransh 11604 
  """
11605 
  Attributes:
3064 chandransh 11606 
   - orderId
1113 chandransh 11607 
  """
11608 
 
11609 
  thrift_spec = (
11610 
    None, # 0
3064 chandransh 11611 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11612 
  )
11613 
 
3064 chandransh 11614 
  def __init__(self, orderId=None,):
11615 
    self.orderId = orderId
1113 chandransh 11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      if fid == 1:
11627 
        if ftype == TType.I64:
3064 chandransh 11628 
          self.orderId = iprot.readI64();
1113 chandransh 11629 
        else:
11630 
          iprot.skip(ftype)
11631 
      else:
11632 
        iprot.skip(ftype)
11633 
      iprot.readFieldEnd()
11634 
    iprot.readStructEnd()
11635 
 
11636 
  def write(self, oprot):
11637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11639 
      return
3064 chandransh 11640 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11641 
    if self.orderId is not None:
3064 chandransh 11642 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11643 
      oprot.writeI64(self.orderId)
1113 chandransh 11644 
      oprot.writeFieldEnd()
11645 
    oprot.writeFieldStop()
11646 
    oprot.writeStructEnd()
11647 
 
3431 rajveer 11648 
  def validate(self):
11649 
    return
11650 
 
11651 
 
1113 chandransh 11652 
  def __repr__(self):
11653 
    L = ['%s=%r' % (key, value)
11654 
      for key, value in self.__dict__.iteritems()]
11655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11656 
 
11657 
  def __eq__(self, other):
11658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11659 
 
11660 
  def __ne__(self, other):
11661 
    return not (self == other)
11662 
 
3064 chandransh 11663 
class acceptOrder_result:
1113 chandransh 11664 
  """
11665 
  Attributes:
11666 
   - success
11667 
   - ex
11668 
  """
11669 
 
11670 
  thrift_spec = (
3064 chandransh 11671 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11673 
  )
11674 
 
11675 
  def __init__(self, success=None, ex=None,):
11676 
    self.success = success
11677 
    self.ex = ex
11678 
 
11679 
  def read(self, iprot):
11680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11682 
      return
11683 
    iprot.readStructBegin()
11684 
    while True:
11685 
      (fname, ftype, fid) = iprot.readFieldBegin()
11686 
      if ftype == TType.STOP:
11687 
        break
11688 
      if fid == 0:
3064 chandransh 11689 
        if ftype == TType.BOOL:
11690 
          self.success = iprot.readBool();
1113 chandransh 11691 
        else:
11692 
          iprot.skip(ftype)
11693 
      elif fid == 1:
11694 
        if ftype == TType.STRUCT:
11695 
          self.ex = TransactionServiceException()
11696 
          self.ex.read(iprot)
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_result')
3431 rajveer 11709 
    if self.success is not None:
3064 chandransh 11710 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11711 
      oprot.writeBool(self.success)
1113 chandransh 11712 
      oprot.writeFieldEnd()
3431 rajveer 11713 
    if self.ex is not None:
1113 chandransh 11714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11715 
      self.ex.write(oprot)
11716 
      oprot.writeFieldEnd()
11717 
    oprot.writeFieldStop()
11718 
    oprot.writeStructEnd()
11719 
 
3431 rajveer 11720 
  def validate(self):
11721 
    return
11722 
 
11723 
 
1113 chandransh 11724 
  def __repr__(self):
11725 
    L = ['%s=%r' % (key, value)
11726 
      for key, value in self.__dict__.iteritems()]
11727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11728 
 
11729 
  def __eq__(self, other):
11730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11731 
 
11732 
  def __ne__(self, other):
11733 
    return not (self == other)
11734 
 
3064 chandransh 11735 
class addBillingDetails_args:
1135 chandransh 11736 
  """
11737 
  Attributes:
3064 chandransh 11738 
   - orderId
11739 
   - invoice_number
4658 mandeep.dh 11740 
   - serialNumber
4283 anupam.sin 11741 
   - itemNumber
3064 chandransh 11742 
   - billed_by
4264 rajveer 11743 
   - jacketNumber
4283 anupam.sin 11744 
   - billingType
5110 mandeep.dh 11745 
   - fulfilmentWarehouseId
4763 rajveer 11746 
   - authorize
1135 chandransh 11747 
  """
11748 
 
11749 
  thrift_spec = (
11750 
    None, # 0
3064 chandransh 11751 
    (1, TType.I64, 'orderId', None, None, ), # 1
11752 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 11753 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
11754 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 11755 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11756 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11757 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11758 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11759 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11760 
  )
11761 
 
5110 mandeep.dh 11762 
  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 11763 
    self.orderId = orderId
11764 
    self.invoice_number = invoice_number
4658 mandeep.dh 11765 
    self.serialNumber = serialNumber
4283 anupam.sin 11766 
    self.itemNumber = itemNumber
3064 chandransh 11767 
    self.billed_by = billed_by
4264 rajveer 11768 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11769 
    self.billingType = billingType
5110 mandeep.dh 11770 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11771 
    self.authorize = authorize
1135 chandransh 11772 
 
11773 
  def read(self, iprot):
11774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11776 
      return
11777 
    iprot.readStructBegin()
11778 
    while True:
11779 
      (fname, ftype, fid) = iprot.readFieldBegin()
11780 
      if ftype == TType.STOP:
11781 
        break
11782 
      if fid == 1:
11783 
        if ftype == TType.I64:
3064 chandransh 11784 
          self.orderId = iprot.readI64();
1135 chandransh 11785 
        else:
11786 
          iprot.skip(ftype)
11787 
      elif fid == 2:
3064 chandransh 11788 
        if ftype == TType.STRING:
11789 
          self.invoice_number = iprot.readString();
1135 chandransh 11790 
        else:
11791 
          iprot.skip(ftype)
3064 chandransh 11792 
      elif fid == 3:
5411 rajveer 11793 
        if ftype == TType.LIST:
11794 
          self.serialNumber = []
11795 
          (_etype227, _size224) = iprot.readListBegin()
11796 
          for _i228 in xrange(_size224):
11797 
            _elem229 = iprot.readString();
11798 
            self.serialNumber.append(_elem229)
11799 
          iprot.readListEnd()
3064 chandransh 11800 
        else:
11801 
          iprot.skip(ftype)
11802 
      elif fid == 4:
5411 rajveer 11803 
        if ftype == TType.LIST:
11804 
          self.itemNumber = []
11805 
          (_etype233, _size230) = iprot.readListBegin()
11806 
          for _i234 in xrange(_size230):
11807 
            _elem235 = iprot.readString();
11808 
            self.itemNumber.append(_elem235)
11809 
          iprot.readListEnd()
3064 chandransh 11810 
        else:
11811 
          iprot.skip(ftype)
11812 
      elif fid == 5:
11813 
        if ftype == TType.STRING:
4283 anupam.sin 11814 
          self.billed_by = iprot.readString();
3064 chandransh 11815 
        else:
11816 
          iprot.skip(ftype)
11817 
      elif fid == 6:
11818 
        if ftype == TType.I64:
4283 anupam.sin 11819 
          self.jacketNumber = iprot.readI64();
11820 
        else:
11821 
          iprot.skip(ftype)
11822 
      elif fid == 7:
11823 
        if ftype == TType.I64:
3064 chandransh 11824 
          self.billingType = iprot.readI64();
11825 
        else:
11826 
          iprot.skip(ftype)
4283 anupam.sin 11827 
      elif fid == 8:
11828 
        if ftype == TType.I64:
5110 mandeep.dh 11829 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11830 
        else:
11831 
          iprot.skip(ftype)
4763 rajveer 11832 
      elif fid == 9:
11833 
        if ftype == TType.BOOL:
11834 
          self.authorize = iprot.readBool();
11835 
        else:
11836 
          iprot.skip(ftype)
1246 chandransh 11837 
      else:
11838 
        iprot.skip(ftype)
11839 
      iprot.readFieldEnd()
11840 
    iprot.readStructEnd()
11841 
 
11842 
  def write(self, oprot):
11843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11845 
      return
4283 anupam.sin 11846 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11847 
    if self.orderId is not None:
3064 chandransh 11848 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11849 
      oprot.writeI64(self.orderId)
1246 chandransh 11850 
      oprot.writeFieldEnd()
4283 anupam.sin 11851 
    if self.invoice_number is not None:
11852 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11853 
      oprot.writeString(self.invoice_number)
1246 chandransh 11854 
      oprot.writeFieldEnd()
4658 mandeep.dh 11855 
    if self.serialNumber is not None:
5411 rajveer 11856 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
11857 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
11858 
      for iter236 in self.serialNumber:
11859 
        oprot.writeString(iter236)
11860 
      oprot.writeListEnd()
3064 chandransh 11861 
      oprot.writeFieldEnd()
3431 rajveer 11862 
    if self.itemNumber is not None:
5411 rajveer 11863 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
11864 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
11865 
      for iter237 in self.itemNumber:
11866 
        oprot.writeString(iter237)
11867 
      oprot.writeListEnd()
3064 chandransh 11868 
      oprot.writeFieldEnd()
4283 anupam.sin 11869 
    if self.billed_by is not None:
11870 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11871 
      oprot.writeString(self.billed_by)
3064 chandransh 11872 
      oprot.writeFieldEnd()
4283 anupam.sin 11873 
    if self.jacketNumber is not None:
11874 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11875 
      oprot.writeI64(self.jacketNumber)
11876 
      oprot.writeFieldEnd()
3431 rajveer 11877 
    if self.billingType is not None:
4283 anupam.sin 11878 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11879 
      oprot.writeI64(self.billingType)
11880 
      oprot.writeFieldEnd()
5110 mandeep.dh 11881 
    if self.fulfilmentWarehouseId is not None:
11882 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11883 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11884 
      oprot.writeFieldEnd()
4763 rajveer 11885 
    if self.authorize is not None:
11886 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11887 
      oprot.writeBool(self.authorize)
11888 
      oprot.writeFieldEnd()
1246 chandransh 11889 
    oprot.writeFieldStop()
11890 
    oprot.writeStructEnd()
11891 
 
3431 rajveer 11892 
  def validate(self):
11893 
    return
11894 
 
11895 
 
1246 chandransh 11896 
  def __repr__(self):
11897 
    L = ['%s=%r' % (key, value)
11898 
      for key, value in self.__dict__.iteritems()]
11899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11900 
 
11901 
  def __eq__(self, other):
11902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11903 
 
11904 
  def __ne__(self, other):
11905 
    return not (self == other)
11906 
 
4283 anupam.sin 11907 
class addBillingDetails_result:
1246 chandransh 11908 
  """
11909 
  Attributes:
3064 chandransh 11910 
   - success
1246 chandransh 11911 
   - ex
11912 
  """
11913 
 
11914 
  thrift_spec = (
3064 chandransh 11915 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11917 
  )
11918 
 
3064 chandransh 11919 
  def __init__(self, success=None, ex=None,):
11920 
    self.success = success
1246 chandransh 11921 
    self.ex = ex
11922 
 
11923 
  def read(self, iprot):
11924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11926 
      return
11927 
    iprot.readStructBegin()
11928 
    while True:
11929 
      (fname, ftype, fid) = iprot.readFieldBegin()
11930 
      if ftype == TType.STOP:
11931 
        break
3064 chandransh 11932 
      if fid == 0:
11933 
        if ftype == TType.BOOL:
11934 
          self.success = iprot.readBool();
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      elif fid == 1:
1246 chandransh 11938 
        if ftype == TType.STRUCT:
11939 
          self.ex = TransactionServiceException()
11940 
          self.ex.read(iprot)
11941 
        else:
11942 
          iprot.skip(ftype)
11943 
      else:
11944 
        iprot.skip(ftype)
11945 
      iprot.readFieldEnd()
11946 
    iprot.readStructEnd()
11947 
 
11948 
  def write(self, oprot):
11949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11951 
      return
4283 anupam.sin 11952 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11953 
    if self.success is not None:
3064 chandransh 11954 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11955 
      oprot.writeBool(self.success)
11956 
      oprot.writeFieldEnd()
3431 rajveer 11957 
    if self.ex is not None:
1246 chandransh 11958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11959 
      self.ex.write(oprot)
11960 
      oprot.writeFieldEnd()
11961 
    oprot.writeFieldStop()
11962 
    oprot.writeStructEnd()
11963 
 
3431 rajveer 11964 
  def validate(self):
11965 
    return
11966 
 
11967 
 
1246 chandransh 11968 
  def __repr__(self):
11969 
    L = ['%s=%r' % (key, value)
11970 
      for key, value in self.__dict__.iteritems()]
11971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11972 
 
11973 
  def __eq__(self, other):
11974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11975 
 
11976 
  def __ne__(self, other):
11977 
    return not (self == other)
11978 
 
4579 rajveer 11979 
class addInvoiceNumber_args:
11980 
  """
11981 
  Attributes:
11982 
   - orderId
11983 
   - invoiceNumber
4763 rajveer 11984 
   - color
4579 rajveer 11985 
  """
11986 
 
11987 
  thrift_spec = (
11988 
    None, # 0
11989 
    (1, TType.I64, 'orderId', None, None, ), # 1
11990 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11991 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11992 
  )
11993 
 
4763 rajveer 11994 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11995 
    self.orderId = orderId
11996 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11997 
    self.color = color
4579 rajveer 11998 
 
11999 
  def read(self, iprot):
12000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12002 
      return
12003 
    iprot.readStructBegin()
12004 
    while True:
12005 
      (fname, ftype, fid) = iprot.readFieldBegin()
12006 
      if ftype == TType.STOP:
12007 
        break
12008 
      if fid == 1:
12009 
        if ftype == TType.I64:
12010 
          self.orderId = iprot.readI64();
12011 
        else:
12012 
          iprot.skip(ftype)
12013 
      elif fid == 2:
12014 
        if ftype == TType.STRING:
12015 
          self.invoiceNumber = iprot.readString();
12016 
        else:
12017 
          iprot.skip(ftype)
4763 rajveer 12018 
      elif fid == 3:
12019 
        if ftype == TType.STRING:
12020 
          self.color = iprot.readString();
12021 
        else:
12022 
          iprot.skip(ftype)
4579 rajveer 12023 
      else:
12024 
        iprot.skip(ftype)
12025 
      iprot.readFieldEnd()
12026 
    iprot.readStructEnd()
12027 
 
12028 
  def write(self, oprot):
12029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12031 
      return
12032 
    oprot.writeStructBegin('addInvoiceNumber_args')
12033 
    if self.orderId is not None:
12034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12035 
      oprot.writeI64(self.orderId)
12036 
      oprot.writeFieldEnd()
12037 
    if self.invoiceNumber is not None:
12038 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12039 
      oprot.writeString(self.invoiceNumber)
12040 
      oprot.writeFieldEnd()
4763 rajveer 12041 
    if self.color is not None:
12042 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12043 
      oprot.writeString(self.color)
12044 
      oprot.writeFieldEnd()
4579 rajveer 12045 
    oprot.writeFieldStop()
12046 
    oprot.writeStructEnd()
12047 
 
12048 
  def validate(self):
12049 
    return
12050 
 
12051 
 
12052 
  def __repr__(self):
12053 
    L = ['%s=%r' % (key, value)
12054 
      for key, value in self.__dict__.iteritems()]
12055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12056 
 
12057 
  def __eq__(self, other):
12058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12059 
 
12060 
  def __ne__(self, other):
12061 
    return not (self == other)
12062 
 
12063 
class addInvoiceNumber_result:
12064 
  """
12065 
  Attributes:
12066 
   - ex
12067 
  """
12068 
 
12069 
  thrift_spec = (
12070 
    None, # 0
12071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12072 
  )
12073 
 
12074 
  def __init__(self, ex=None,):
12075 
    self.ex = ex
12076 
 
12077 
  def read(self, iprot):
12078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12080 
      return
12081 
    iprot.readStructBegin()
12082 
    while True:
12083 
      (fname, ftype, fid) = iprot.readFieldBegin()
12084 
      if ftype == TType.STOP:
12085 
        break
12086 
      if fid == 1:
12087 
        if ftype == TType.STRUCT:
12088 
          self.ex = TransactionServiceException()
12089 
          self.ex.read(iprot)
12090 
        else:
12091 
          iprot.skip(ftype)
12092 
      else:
12093 
        iprot.skip(ftype)
12094 
      iprot.readFieldEnd()
12095 
    iprot.readStructEnd()
12096 
 
12097 
  def write(self, oprot):
12098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12100 
      return
12101 
    oprot.writeStructBegin('addInvoiceNumber_result')
12102 
    if self.ex is not None:
12103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12104 
      self.ex.write(oprot)
12105 
      oprot.writeFieldEnd()
12106 
    oprot.writeFieldStop()
12107 
    oprot.writeStructEnd()
12108 
 
12109 
  def validate(self):
12110 
    return
12111 
 
12112 
 
12113 
  def __repr__(self):
12114 
    L = ['%s=%r' % (key, value)
12115 
      for key, value in self.__dict__.iteritems()]
12116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12117 
 
12118 
  def __eq__(self, other):
12119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12120 
 
12121 
  def __ne__(self, other):
12122 
    return not (self == other)
12123 
 
4910 phani.kuma 12124 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12125 
  """
12126 
  Attributes:
3064 chandransh 12127 
   - warehouseId
1408 ankur.sing 12128 
   - providerId
3064 chandransh 12129 
   - cod
4910 phani.kuma 12130 
   - orderIds
1408 ankur.sing 12131 
  """
12132 
 
12133 
  thrift_spec = (
12134 
    None, # 0
3064 chandransh 12135 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12136 
    (2, TType.I64, 'providerId', None, None, ), # 2
12137 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12138 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12139 
  )
12140 
 
4910 phani.kuma 12141 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12142 
    self.warehouseId = warehouseId
1408 ankur.sing 12143 
    self.providerId = providerId
3064 chandransh 12144 
    self.cod = cod
4910 phani.kuma 12145 
    self.orderIds = orderIds
1408 ankur.sing 12146 
 
12147 
  def read(self, iprot):
12148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12150 
      return
12151 
    iprot.readStructBegin()
12152 
    while True:
12153 
      (fname, ftype, fid) = iprot.readFieldBegin()
12154 
      if ftype == TType.STOP:
12155 
        break
12156 
      if fid == 1:
12157 
        if ftype == TType.I64:
3064 chandransh 12158 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12159 
        else:
12160 
          iprot.skip(ftype)
12161 
      elif fid == 2:
12162 
        if ftype == TType.I64:
3064 chandransh 12163 
          self.providerId = iprot.readI64();
1408 ankur.sing 12164 
        else:
12165 
          iprot.skip(ftype)
3064 chandransh 12166 
      elif fid == 3:
12167 
        if ftype == TType.BOOL:
12168 
          self.cod = iprot.readBool();
12169 
        else:
12170 
          iprot.skip(ftype)
4910 phani.kuma 12171 
      elif fid == 4:
12172 
        if ftype == TType.LIST:
12173 
          self.orderIds = []
5411 rajveer 12174 
          (_etype241, _size238) = iprot.readListBegin()
12175 
          for _i242 in xrange(_size238):
12176 
            _elem243 = iprot.readI64();
12177 
            self.orderIds.append(_elem243)
4910 phani.kuma 12178 
          iprot.readListEnd()
12179 
        else:
12180 
          iprot.skip(ftype)
1408 ankur.sing 12181 
      else:
12182 
        iprot.skip(ftype)
12183 
      iprot.readFieldEnd()
12184 
    iprot.readStructEnd()
12185 
 
12186 
  def write(self, oprot):
12187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12189 
      return
4910 phani.kuma 12190 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12191 
    if self.warehouseId is not None:
3064 chandransh 12192 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12193 
      oprot.writeI64(self.warehouseId)
12194 
      oprot.writeFieldEnd()
3431 rajveer 12195 
    if self.providerId is not None:
3064 chandransh 12196 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12197 
      oprot.writeI64(self.providerId)
12198 
      oprot.writeFieldEnd()
3431 rajveer 12199 
    if self.cod is not None:
3064 chandransh 12200 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12201 
      oprot.writeBool(self.cod)
1408 ankur.sing 12202 
      oprot.writeFieldEnd()
4910 phani.kuma 12203 
    if self.orderIds is not None:
12204 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12205 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12206 
      for iter244 in self.orderIds:
12207 
        oprot.writeI64(iter244)
4910 phani.kuma 12208 
      oprot.writeListEnd()
12209 
      oprot.writeFieldEnd()
1408 ankur.sing 12210 
    oprot.writeFieldStop()
12211 
    oprot.writeStructEnd()
12212 
 
3431 rajveer 12213 
  def validate(self):
12214 
    return
12215 
 
12216 
 
1408 ankur.sing 12217 
  def __repr__(self):
12218 
    L = ['%s=%r' % (key, value)
12219 
      for key, value in self.__dict__.iteritems()]
12220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12221 
 
12222 
  def __eq__(self, other):
12223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12224 
 
12225 
  def __ne__(self, other):
12226 
    return not (self == other)
12227 
 
4910 phani.kuma 12228 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12229 
  """
12230 
  Attributes:
12231 
   - success
3064 chandransh 12232 
   - ex
1408 ankur.sing 12233 
  """
12234 
 
12235 
  thrift_spec = (
3064 chandransh 12236 
    (0, TType.BOOL, 'success', None, None, ), # 0
12237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12238 
  )
12239 
 
3064 chandransh 12240 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12241 
    self.success = success
3064 chandransh 12242 
    self.ex = ex
1408 ankur.sing 12243 
 
12244 
  def read(self, iprot):
12245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12247 
      return
12248 
    iprot.readStructBegin()
12249 
    while True:
12250 
      (fname, ftype, fid) = iprot.readFieldBegin()
12251 
      if ftype == TType.STOP:
12252 
        break
12253 
      if fid == 0:
3064 chandransh 12254 
        if ftype == TType.BOOL:
12255 
          self.success = iprot.readBool();
1408 ankur.sing 12256 
        else:
12257 
          iprot.skip(ftype)
3064 chandransh 12258 
      elif fid == 1:
12259 
        if ftype == TType.STRUCT:
12260 
          self.ex = TransactionServiceException()
12261 
          self.ex.read(iprot)
12262 
        else:
12263 
          iprot.skip(ftype)
1408 ankur.sing 12264 
      else:
12265 
        iprot.skip(ftype)
12266 
      iprot.readFieldEnd()
12267 
    iprot.readStructEnd()
12268 
 
12269 
  def write(self, oprot):
12270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12272 
      return
4910 phani.kuma 12273 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12274 
    if self.success is not None:
3064 chandransh 12275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12276 
      oprot.writeBool(self.success)
1408 ankur.sing 12277 
      oprot.writeFieldEnd()
3431 rajveer 12278 
    if self.ex is not None:
3064 chandransh 12279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12280 
      self.ex.write(oprot)
12281 
      oprot.writeFieldEnd()
1408 ankur.sing 12282 
    oprot.writeFieldStop()
12283 
    oprot.writeStructEnd()
12284 
 
3431 rajveer 12285 
  def validate(self):
12286 
    return
12287 
 
12288 
 
1408 ankur.sing 12289 
  def __repr__(self):
12290 
    L = ['%s=%r' % (key, value)
12291 
      for key, value in self.__dict__.iteritems()]
12292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12293 
 
12294 
  def __eq__(self, other):
12295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12296 
 
12297 
  def __ne__(self, other):
12298 
    return not (self == other)
12299 
 
4910 phani.kuma 12300 
class markOrdersAsPickedUp_args:
4410 rajveer 12301 
  """
12302 
  Attributes:
12303 
   - providerId
4910 phani.kuma 12304 
   - pickupDetails
4410 rajveer 12305 
  """
12306 
 
12307 
  thrift_spec = (
12308 
    None, # 0
4910 phani.kuma 12309 
    (1, TType.I64, 'providerId', None, None, ), # 1
12310 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 12311 
  )
12312 
 
4910 phani.kuma 12313 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 12314 
    self.providerId = providerId
4910 phani.kuma 12315 
    self.pickupDetails = pickupDetails
4410 rajveer 12316 
 
12317 
  def read(self, iprot):
12318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12320 
      return
12321 
    iprot.readStructBegin()
12322 
    while True:
12323 
      (fname, ftype, fid) = iprot.readFieldBegin()
12324 
      if ftype == TType.STOP:
12325 
        break
12326 
      if fid == 1:
12327 
        if ftype == TType.I64:
4910 phani.kuma 12328 
          self.providerId = iprot.readI64();
4410 rajveer 12329 
        else:
12330 
          iprot.skip(ftype)
12331 
      elif fid == 2:
4910 phani.kuma 12332 
        if ftype == TType.MAP:
12333 
          self.pickupDetails = {}
5411 rajveer 12334 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
12335 
          for _i249 in xrange(_size245):
12336 
            _key250 = iprot.readString();
12337 
            _val251 = iprot.readString();
12338 
            self.pickupDetails[_key250] = _val251
4910 phani.kuma 12339 
          iprot.readMapEnd()
4410 rajveer 12340 
        else:
12341 
          iprot.skip(ftype)
12342 
      else:
12343 
        iprot.skip(ftype)
12344 
      iprot.readFieldEnd()
12345 
    iprot.readStructEnd()
12346 
 
12347 
  def write(self, oprot):
12348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12350 
      return
4910 phani.kuma 12351 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12352 
    if self.providerId is not None:
4910 phani.kuma 12353 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12354 
      oprot.writeI64(self.providerId)
12355 
      oprot.writeFieldEnd()
4910 phani.kuma 12356 
    if self.pickupDetails is not None:
12357 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12358 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 12359 
      for kiter252,viter253 in self.pickupDetails.items():
12360 
        oprot.writeString(kiter252)
12361 
        oprot.writeString(viter253)
4910 phani.kuma 12362 
      oprot.writeMapEnd()
4410 rajveer 12363 
      oprot.writeFieldEnd()
12364 
    oprot.writeFieldStop()
12365 
    oprot.writeStructEnd()
12366 
 
12367 
  def validate(self):
12368 
    return
12369 
 
12370 
 
12371 
  def __repr__(self):
12372 
    L = ['%s=%r' % (key, value)
12373 
      for key, value in self.__dict__.iteritems()]
12374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12375 
 
12376 
  def __eq__(self, other):
12377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12378 
 
12379 
  def __ne__(self, other):
12380 
    return not (self == other)
12381 
 
4910 phani.kuma 12382 
class markOrdersAsPickedUp_result:
4410 rajveer 12383 
  """
12384 
  Attributes:
12385 
   - ex
12386 
  """
12387 
 
12388 
  thrift_spec = (
4910 phani.kuma 12389 
    None, # 0
4410 rajveer 12390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12391 
  )
12392 
 
4910 phani.kuma 12393 
  def __init__(self, ex=None,):
4410 rajveer 12394 
    self.ex = ex
12395 
 
12396 
  def read(self, iprot):
12397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12399 
      return
12400 
    iprot.readStructBegin()
12401 
    while True:
12402 
      (fname, ftype, fid) = iprot.readFieldBegin()
12403 
      if ftype == TType.STOP:
12404 
        break
4910 phani.kuma 12405 
      if fid == 1:
4410 rajveer 12406 
        if ftype == TType.STRUCT:
12407 
          self.ex = TransactionServiceException()
12408 
          self.ex.read(iprot)
12409 
        else:
12410 
          iprot.skip(ftype)
12411 
      else:
12412 
        iprot.skip(ftype)
12413 
      iprot.readFieldEnd()
12414 
    iprot.readStructEnd()
12415 
 
12416 
  def write(self, oprot):
12417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12419 
      return
4910 phani.kuma 12420 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12421 
    if self.ex is not None:
12422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12423 
      self.ex.write(oprot)
12424 
      oprot.writeFieldEnd()
12425 
    oprot.writeFieldStop()
12426 
    oprot.writeStructEnd()
12427 
 
12428 
  def validate(self):
12429 
    return
12430 
 
12431 
 
12432 
  def __repr__(self):
12433 
    L = ['%s=%r' % (key, value)
12434 
      for key, value in self.__dict__.iteritems()]
12435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12436 
 
12437 
  def __eq__(self, other):
12438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12439 
 
12440 
  def __ne__(self, other):
12441 
    return not (self == other)
12442 
 
4910 phani.kuma 12443 
class getOrdersNotPickedUp_args:
304 ashish 12444 
  """
12445 
  Attributes:
3064 chandransh 12446 
   - providerId
304 ashish 12447 
  """
94 ashish 12448 
 
304 ashish 12449 
  thrift_spec = (
12450 
    None, # 0
3064 chandransh 12451 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12452 
  )
12453 
 
4910 phani.kuma 12454 
  def __init__(self, providerId=None,):
3064 chandransh 12455 
    self.providerId = providerId
304 ashish 12456 
 
12457 
  def read(self, iprot):
12458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12460 
      return
12461 
    iprot.readStructBegin()
12462 
    while True:
12463 
      (fname, ftype, fid) = iprot.readFieldBegin()
12464 
      if ftype == TType.STOP:
12465 
        break
12466 
      if fid == 1:
12467 
        if ftype == TType.I64:
3064 chandransh 12468 
          self.providerId = iprot.readI64();
304 ashish 12469 
        else:
12470 
          iprot.skip(ftype)
12471 
      else:
12472 
        iprot.skip(ftype)
12473 
      iprot.readFieldEnd()
12474 
    iprot.readStructEnd()
12475 
 
12476 
  def write(self, oprot):
12477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12479 
      return
4910 phani.kuma 12480 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12481 
    if self.providerId is not None:
3064 chandransh 12482 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12483 
      oprot.writeI64(self.providerId)
304 ashish 12484 
      oprot.writeFieldEnd()
12485 
    oprot.writeFieldStop()
12486 
    oprot.writeStructEnd()
12487 
 
3431 rajveer 12488 
  def validate(self):
12489 
    return
12490 
 
12491 
 
304 ashish 12492 
  def __repr__(self):
12493 
    L = ['%s=%r' % (key, value)
12494 
      for key, value in self.__dict__.iteritems()]
12495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12496 
 
12497 
  def __eq__(self, other):
12498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12499 
 
12500 
  def __ne__(self, other):
12501 
    return not (self == other)
12502 
 
4910 phani.kuma 12503 
class getOrdersNotPickedUp_result:
304 ashish 12504 
  """
12505 
  Attributes:
12506 
   - success
12507 
  """
12508 
 
12509 
  thrift_spec = (
3064 chandransh 12510 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12511 
  )
12512 
 
4910 phani.kuma 12513 
  def __init__(self, success=None,):
304 ashish 12514 
    self.success = success
12515 
 
12516 
  def read(self, iprot):
12517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12519 
      return
12520 
    iprot.readStructBegin()
12521 
    while True:
12522 
      (fname, ftype, fid) = iprot.readFieldBegin()
12523 
      if ftype == TType.STOP:
12524 
        break
12525 
      if fid == 0:
12526 
        if ftype == TType.LIST:
12527 
          self.success = []
5411 rajveer 12528 
          (_etype257, _size254) = iprot.readListBegin()
12529 
          for _i258 in xrange(_size254):
12530 
            _elem259 = Order()
12531 
            _elem259.read(iprot)
12532 
            self.success.append(_elem259)
304 ashish 12533 
          iprot.readListEnd()
12534 
        else:
12535 
          iprot.skip(ftype)
12536 
      else:
12537 
        iprot.skip(ftype)
12538 
      iprot.readFieldEnd()
12539 
    iprot.readStructEnd()
12540 
 
12541 
  def write(self, oprot):
12542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12544 
      return
4910 phani.kuma 12545 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12546 
    if self.success is not None:
304 ashish 12547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12548 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12549 
      for iter260 in self.success:
12550 
        iter260.write(oprot)
304 ashish 12551 
      oprot.writeListEnd()
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 
 
3064 chandransh 12571 
class markOrdersAsDelivered_args:
304 ashish 12572 
  """
12573 
  Attributes:
3064 chandransh 12574 
   - providerId
12575 
   - deliveredOrders
304 ashish 12576 
  """
12577 
 
12578 
  thrift_spec = (
12579 
    None, # 0
3064 chandransh 12580 
    (1, TType.I64, 'providerId', None, None, ), # 1
12581 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12582 
  )
12583 
 
3064 chandransh 12584 
  def __init__(self, providerId=None, deliveredOrders=None,):
12585 
    self.providerId = providerId
12586 
    self.deliveredOrders = deliveredOrders
304 ashish 12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
12597 
      if fid == 1:
12598 
        if ftype == TType.I64:
3064 chandransh 12599 
          self.providerId = iprot.readI64();
304 ashish 12600 
        else:
12601 
          iprot.skip(ftype)
12602 
      elif fid == 2:
3064 chandransh 12603 
        if ftype == TType.MAP:
12604 
          self.deliveredOrders = {}
5411 rajveer 12605 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
12606 
          for _i265 in xrange(_size261):
12607 
            _key266 = iprot.readString();
12608 
            _val267 = iprot.readString();
12609 
            self.deliveredOrders[_key266] = _val267
3064 chandransh 12610 
          iprot.readMapEnd()
304 ashish 12611 
        else:
12612 
          iprot.skip(ftype)
12613 
      else:
12614 
        iprot.skip(ftype)
12615 
      iprot.readFieldEnd()
12616 
    iprot.readStructEnd()
12617 
 
12618 
  def write(self, oprot):
12619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12621 
      return
3064 chandransh 12622 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12623 
    if self.providerId is not None:
3064 chandransh 12624 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12625 
      oprot.writeI64(self.providerId)
304 ashish 12626 
      oprot.writeFieldEnd()
3431 rajveer 12627 
    if self.deliveredOrders is not None:
3064 chandransh 12628 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12629 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5411 rajveer 12630 
      for kiter268,viter269 in self.deliveredOrders.items():
12631 
        oprot.writeString(kiter268)
12632 
        oprot.writeString(viter269)
3064 chandransh 12633 
      oprot.writeMapEnd()
304 ashish 12634 
      oprot.writeFieldEnd()
12635 
    oprot.writeFieldStop()
12636 
    oprot.writeStructEnd()
12637 
 
3431 rajveer 12638 
  def validate(self):
12639 
    return
12640 
 
12641 
 
304 ashish 12642 
  def __repr__(self):
12643 
    L = ['%s=%r' % (key, value)
12644 
      for key, value in self.__dict__.iteritems()]
12645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12646 
 
12647 
  def __eq__(self, other):
12648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12649 
 
12650 
  def __ne__(self, other):
12651 
    return not (self == other)
12652 
 
3064 chandransh 12653 
class markOrdersAsDelivered_result:
12654 
  """
12655 
  Attributes:
12656 
   - ex
12657 
  """
304 ashish 12658 
 
12659 
  thrift_spec = (
3064 chandransh 12660 
    None, # 0
12661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12662 
  )
12663 
 
3064 chandransh 12664 
  def __init__(self, ex=None,):
12665 
    self.ex = ex
304 ashish 12666 
 
1596 ankur.sing 12667 
  def read(self, iprot):
12668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12670 
      return
12671 
    iprot.readStructBegin()
12672 
    while True:
12673 
      (fname, ftype, fid) = iprot.readFieldBegin()
12674 
      if ftype == TType.STOP:
12675 
        break
3064 chandransh 12676 
      if fid == 1:
12677 
        if ftype == TType.STRUCT:
12678 
          self.ex = TransactionServiceException()
12679 
          self.ex.read(iprot)
12680 
        else:
12681 
          iprot.skip(ftype)
1596 ankur.sing 12682 
      else:
12683 
        iprot.skip(ftype)
12684 
      iprot.readFieldEnd()
12685 
    iprot.readStructEnd()
12686 
 
12687 
  def write(self, oprot):
12688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12690 
      return
3064 chandransh 12691 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12692 
    if self.ex is not None:
3064 chandransh 12693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12694 
      self.ex.write(oprot)
12695 
      oprot.writeFieldEnd()
1596 ankur.sing 12696 
    oprot.writeFieldStop()
12697 
    oprot.writeStructEnd()
12698 
 
3431 rajveer 12699 
  def validate(self):
12700 
    return
12701 
 
12702 
 
1596 ankur.sing 12703 
  def __repr__(self):
12704 
    L = ['%s=%r' % (key, value)
12705 
      for key, value in self.__dict__.iteritems()]
12706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12707 
 
12708 
  def __eq__(self, other):
12709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12710 
 
12711 
  def __ne__(self, other):
12712 
    return not (self == other)
12713 
 
4910 phani.kuma 12714 
class markAsRTOrders_args:
1596 ankur.sing 12715 
  """
12716 
  Attributes:
3064 chandransh 12717 
   - providerId
12718 
   - returnedOrders
1596 ankur.sing 12719 
  """
12720 
 
12721 
  thrift_spec = (
3064 chandransh 12722 
    None, # 0
12723 
    (1, TType.I64, 'providerId', None, None, ), # 1
12724 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12725 
  )
12726 
 
3064 chandransh 12727 
  def __init__(self, providerId=None, returnedOrders=None,):
12728 
    self.providerId = providerId
12729 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
3064 chandransh 12740 
      if fid == 1:
1596 ankur.sing 12741 
        if ftype == TType.I64:
3064 chandransh 12742 
          self.providerId = iprot.readI64();
1596 ankur.sing 12743 
        else:
12744 
          iprot.skip(ftype)
3064 chandransh 12745 
      elif fid == 2:
12746 
        if ftype == TType.MAP:
12747 
          self.returnedOrders = {}
5411 rajveer 12748 
          (_ktype271, _vtype272, _size270 ) = iprot.readMapBegin()
12749 
          for _i274 in xrange(_size270):
12750 
            _key275 = iprot.readString();
12751 
            _val276 = iprot.readString();
12752 
            self.returnedOrders[_key275] = _val276
3064 chandransh 12753 
          iprot.readMapEnd()
12754 
        else:
12755 
          iprot.skip(ftype)
1596 ankur.sing 12756 
      else:
12757 
        iprot.skip(ftype)
12758 
      iprot.readFieldEnd()
12759 
    iprot.readStructEnd()
12760 
 
12761 
  def write(self, oprot):
12762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12764 
      return
4910 phani.kuma 12765 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12766 
    if self.providerId is not None:
3064 chandransh 12767 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12768 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12769 
      oprot.writeFieldEnd()
3431 rajveer 12770 
    if self.returnedOrders is not None:
3064 chandransh 12771 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12772 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5411 rajveer 12773 
      for kiter277,viter278 in self.returnedOrders.items():
12774 
        oprot.writeString(kiter277)
12775 
        oprot.writeString(viter278)
3064 chandransh 12776 
      oprot.writeMapEnd()
12777 
      oprot.writeFieldEnd()
1596 ankur.sing 12778 
    oprot.writeFieldStop()
12779 
    oprot.writeStructEnd()
12780 
 
3431 rajveer 12781 
  def validate(self):
12782 
    return
12783 
 
12784 
 
1596 ankur.sing 12785 
  def __repr__(self):
12786 
    L = ['%s=%r' % (key, value)
12787 
      for key, value in self.__dict__.iteritems()]
12788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12789 
 
12790 
  def __eq__(self, other):
12791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12792 
 
12793 
  def __ne__(self, other):
12794 
    return not (self == other)
12795 
 
4910 phani.kuma 12796 
class markAsRTOrders_result:
3064 chandransh 12797 
  """
12798 
  Attributes:
12799 
   - ex
12800 
  """
1596 ankur.sing 12801 
 
1627 ankur.sing 12802 
  thrift_spec = (
3064 chandransh 12803 
    None, # 0
12804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12805 
  )
12806 
 
3064 chandransh 12807 
  def __init__(self, ex=None,):
12808 
    self.ex = ex
12809 
 
1627 ankur.sing 12810 
  def read(self, iprot):
12811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12813 
      return
12814 
    iprot.readStructBegin()
12815 
    while True:
12816 
      (fname, ftype, fid) = iprot.readFieldBegin()
12817 
      if ftype == TType.STOP:
12818 
        break
3064 chandransh 12819 
      if fid == 1:
12820 
        if ftype == TType.STRUCT:
12821 
          self.ex = TransactionServiceException()
12822 
          self.ex.read(iprot)
12823 
        else:
12824 
          iprot.skip(ftype)
1627 ankur.sing 12825 
      else:
12826 
        iprot.skip(ftype)
12827 
      iprot.readFieldEnd()
12828 
    iprot.readStructEnd()
12829 
 
12830 
  def write(self, oprot):
12831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12833 
      return
4910 phani.kuma 12834 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12835 
    if self.ex is not None:
3064 chandransh 12836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12837 
      self.ex.write(oprot)
12838 
      oprot.writeFieldEnd()
1627 ankur.sing 12839 
    oprot.writeFieldStop()
12840 
    oprot.writeStructEnd()
12841 
 
3431 rajveer 12842 
  def validate(self):
12843 
    return
12844 
 
12845 
 
1627 ankur.sing 12846 
  def __repr__(self):
12847 
    L = ['%s=%r' % (key, value)
12848 
      for key, value in self.__dict__.iteritems()]
12849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12850 
 
12851 
  def __eq__(self, other):
12852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12853 
 
12854 
  def __ne__(self, other):
12855 
    return not (self == other)
12856 
 
4910 phani.kuma 12857 
class getRTOrders_args:
12858 
  """
12859 
  Attributes:
12860 
   - providerId
12861 
  """
12862 
 
12863 
  thrift_spec = (
12864 
    None, # 0
12865 
    (1, TType.I64, 'providerId', None, None, ), # 1
12866 
  )
12867 
 
12868 
  def __init__(self, providerId=None,):
12869 
    self.providerId = providerId
12870 
 
12871 
  def read(self, iprot):
12872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12874 
      return
12875 
    iprot.readStructBegin()
12876 
    while True:
12877 
      (fname, ftype, fid) = iprot.readFieldBegin()
12878 
      if ftype == TType.STOP:
12879 
        break
12880 
      if fid == 1:
12881 
        if ftype == TType.I64:
12882 
          self.providerId = iprot.readI64();
12883 
        else:
12884 
          iprot.skip(ftype)
12885 
      else:
12886 
        iprot.skip(ftype)
12887 
      iprot.readFieldEnd()
12888 
    iprot.readStructEnd()
12889 
 
12890 
  def write(self, oprot):
12891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12893 
      return
12894 
    oprot.writeStructBegin('getRTOrders_args')
12895 
    if self.providerId is not None:
12896 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12897 
      oprot.writeI64(self.providerId)
12898 
      oprot.writeFieldEnd()
12899 
    oprot.writeFieldStop()
12900 
    oprot.writeStructEnd()
12901 
 
12902 
  def validate(self):
12903 
    return
12904 
 
12905 
 
12906 
  def __repr__(self):
12907 
    L = ['%s=%r' % (key, value)
12908 
      for key, value in self.__dict__.iteritems()]
12909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12910 
 
12911 
  def __eq__(self, other):
12912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12913 
 
12914 
  def __ne__(self, other):
12915 
    return not (self == other)
12916 
 
12917 
class getRTOrders_result:
12918 
  """
12919 
  Attributes:
12920 
   - success
12921 
  """
12922 
 
12923 
  thrift_spec = (
12924 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12925 
  )
12926 
 
12927 
  def __init__(self, success=None,):
12928 
    self.success = success
12929 
 
12930 
  def read(self, iprot):
12931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12933 
      return
12934 
    iprot.readStructBegin()
12935 
    while True:
12936 
      (fname, ftype, fid) = iprot.readFieldBegin()
12937 
      if ftype == TType.STOP:
12938 
        break
12939 
      if fid == 0:
12940 
        if ftype == TType.LIST:
12941 
          self.success = []
5411 rajveer 12942 
          (_etype282, _size279) = iprot.readListBegin()
12943 
          for _i283 in xrange(_size279):
12944 
            _elem284 = Order()
12945 
            _elem284.read(iprot)
12946 
            self.success.append(_elem284)
4910 phani.kuma 12947 
          iprot.readListEnd()
12948 
        else:
12949 
          iprot.skip(ftype)
12950 
      else:
12951 
        iprot.skip(ftype)
12952 
      iprot.readFieldEnd()
12953 
    iprot.readStructEnd()
12954 
 
12955 
  def write(self, oprot):
12956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12958 
      return
12959 
    oprot.writeStructBegin('getRTOrders_result')
12960 
    if self.success is not None:
12961 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12962 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 12963 
      for iter285 in self.success:
12964 
        iter285.write(oprot)
4910 phani.kuma 12965 
      oprot.writeListEnd()
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 
 
3064 chandransh 12985 
class updateNonDeliveryReason_args:
1627 ankur.sing 12986 
  """
12987 
  Attributes:
3064 chandransh 12988 
   - providerId
12989 
   - undeliveredOrders
1627 ankur.sing 12990 
  """
12991 
 
12992 
  thrift_spec = (
3064 chandransh 12993 
    None, # 0
12994 
    (1, TType.I64, 'providerId', None, None, ), # 1
12995 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12996 
  )
12997 
 
3064 chandransh 12998 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12999 
    self.providerId = providerId
13000 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13001 
 
13002 
  def read(self, iprot):
13003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13005 
      return
13006 
    iprot.readStructBegin()
13007 
    while True:
13008 
      (fname, ftype, fid) = iprot.readFieldBegin()
13009 
      if ftype == TType.STOP:
13010 
        break
3064 chandransh 13011 
      if fid == 1:
1627 ankur.sing 13012 
        if ftype == TType.I64:
3064 chandransh 13013 
          self.providerId = iprot.readI64();
1627 ankur.sing 13014 
        else:
13015 
          iprot.skip(ftype)
3064 chandransh 13016 
      elif fid == 2:
13017 
        if ftype == TType.MAP:
13018 
          self.undeliveredOrders = {}
5411 rajveer 13019 
          (_ktype287, _vtype288, _size286 ) = iprot.readMapBegin()
13020 
          for _i290 in xrange(_size286):
13021 
            _key291 = iprot.readString();
13022 
            _val292 = iprot.readString();
13023 
            self.undeliveredOrders[_key291] = _val292
3064 chandransh 13024 
          iprot.readMapEnd()
13025 
        else:
13026 
          iprot.skip(ftype)
1627 ankur.sing 13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
3064 chandransh 13036 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13037 
    if self.providerId is not None:
3064 chandransh 13038 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13039 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13040 
      oprot.writeFieldEnd()
3431 rajveer 13041 
    if self.undeliveredOrders is not None:
3064 chandransh 13042 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13043 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5411 rajveer 13044 
      for kiter293,viter294 in self.undeliveredOrders.items():
13045 
        oprot.writeString(kiter293)
13046 
        oprot.writeString(viter294)
3064 chandransh 13047 
      oprot.writeMapEnd()
13048 
      oprot.writeFieldEnd()
1627 ankur.sing 13049 
    oprot.writeFieldStop()
13050 
    oprot.writeStructEnd()
13051 
 
3431 rajveer 13052 
  def validate(self):
13053 
    return
13054 
 
13055 
 
1627 ankur.sing 13056 
  def __repr__(self):
13057 
    L = ['%s=%r' % (key, value)
13058 
      for key, value in self.__dict__.iteritems()]
13059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13060 
 
13061 
  def __eq__(self, other):
13062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13063 
 
13064 
  def __ne__(self, other):
13065 
    return not (self == other)
13066 
 
3064 chandransh 13067 
class updateNonDeliveryReason_result:
1627 ankur.sing 13068 
  """
13069 
  Attributes:
3064 chandransh 13070 
   - ex
1627 ankur.sing 13071 
  """
13072 
 
13073 
  thrift_spec = (
4910 phani.kuma 13074 
    None, # 0
3064 chandransh 13075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13076 
  )
13077 
 
4910 phani.kuma 13078 
  def __init__(self, ex=None,):
3064 chandransh 13079 
    self.ex = ex
1627 ankur.sing 13080 
 
13081 
  def read(self, iprot):
13082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13084 
      return
13085 
    iprot.readStructBegin()
13086 
    while True:
13087 
      (fname, ftype, fid) = iprot.readFieldBegin()
13088 
      if ftype == TType.STOP:
13089 
        break
4910 phani.kuma 13090 
      if fid == 1:
13091 
        if ftype == TType.STRUCT:
13092 
          self.ex = TransactionServiceException()
13093 
          self.ex.read(iprot)
13094 
        else:
13095 
          iprot.skip(ftype)
13096 
      else:
13097 
        iprot.skip(ftype)
13098 
      iprot.readFieldEnd()
13099 
    iprot.readStructEnd()
13100 
 
13101 
  def write(self, oprot):
13102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13104 
      return
13105 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13106 
    if self.ex is not None:
13107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13108 
      self.ex.write(oprot)
13109 
      oprot.writeFieldEnd()
13110 
    oprot.writeFieldStop()
13111 
    oprot.writeStructEnd()
13112 
 
13113 
  def validate(self):
13114 
    return
13115 
 
13116 
 
13117 
  def __repr__(self):
13118 
    L = ['%s=%r' % (key, value)
13119 
      for key, value in self.__dict__.iteritems()]
13120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13121 
 
13122 
  def __eq__(self, other):
13123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13124 
 
13125 
  def __ne__(self, other):
13126 
    return not (self == other)
13127 
 
13128 
class getNonDeliveredOrdersbyCourier_args:
13129 
  """
13130 
  Attributes:
13131 
   - providerId
13132 
  """
13133 
 
13134 
  thrift_spec = (
13135 
    None, # 0
13136 
    (1, TType.I64, 'providerId', None, None, ), # 1
13137 
  )
13138 
 
13139 
  def __init__(self, providerId=None,):
13140 
    self.providerId = providerId
13141 
 
13142 
  def read(self, iprot):
13143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13145 
      return
13146 
    iprot.readStructBegin()
13147 
    while True:
13148 
      (fname, ftype, fid) = iprot.readFieldBegin()
13149 
      if ftype == TType.STOP:
13150 
        break
13151 
      if fid == 1:
13152 
        if ftype == TType.I64:
13153 
          self.providerId = iprot.readI64();
13154 
        else:
13155 
          iprot.skip(ftype)
13156 
      else:
13157 
        iprot.skip(ftype)
13158 
      iprot.readFieldEnd()
13159 
    iprot.readStructEnd()
13160 
 
13161 
  def write(self, oprot):
13162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13164 
      return
13165 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13166 
    if self.providerId is not None:
13167 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13168 
      oprot.writeI64(self.providerId)
13169 
      oprot.writeFieldEnd()
13170 
    oprot.writeFieldStop()
13171 
    oprot.writeStructEnd()
13172 
 
13173 
  def validate(self):
13174 
    return
13175 
 
13176 
 
13177 
  def __repr__(self):
13178 
    L = ['%s=%r' % (key, value)
13179 
      for key, value in self.__dict__.iteritems()]
13180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13181 
 
13182 
  def __eq__(self, other):
13183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13184 
 
13185 
  def __ne__(self, other):
13186 
    return not (self == other)
13187 
 
13188 
class getNonDeliveredOrdersbyCourier_result:
13189 
  """
13190 
  Attributes:
13191 
   - success
13192 
  """
13193 
 
13194 
  thrift_spec = (
13195 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13196 
  )
13197 
 
13198 
  def __init__(self, success=None,):
13199 
    self.success = success
13200 
 
13201 
  def read(self, iprot):
13202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13204 
      return
13205 
    iprot.readStructBegin()
13206 
    while True:
13207 
      (fname, ftype, fid) = iprot.readFieldBegin()
13208 
      if ftype == TType.STOP:
13209 
        break
4581 phani.kuma 13210 
      if fid == 0:
13211 
        if ftype == TType.LIST:
13212 
          self.success = []
5411 rajveer 13213 
          (_etype298, _size295) = iprot.readListBegin()
13214 
          for _i299 in xrange(_size295):
13215 
            _elem300 = Order()
13216 
            _elem300.read(iprot)
13217 
            self.success.append(_elem300)
4581 phani.kuma 13218 
          iprot.readListEnd()
13219 
        else:
13220 
          iprot.skip(ftype)
4910 phani.kuma 13221 
      else:
13222 
        iprot.skip(ftype)
13223 
      iprot.readFieldEnd()
13224 
    iprot.readStructEnd()
13225 
 
13226 
  def write(self, oprot):
13227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13229 
      return
13230 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13231 
    if self.success is not None:
13232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13234 
      for iter301 in self.success:
13235 
        iter301.write(oprot)
4910 phani.kuma 13236 
      oprot.writeListEnd()
13237 
      oprot.writeFieldEnd()
13238 
    oprot.writeFieldStop()
13239 
    oprot.writeStructEnd()
13240 
 
13241 
  def validate(self):
13242 
    return
13243 
 
13244 
 
13245 
  def __repr__(self):
13246 
    L = ['%s=%r' % (key, value)
13247 
      for key, value in self.__dict__.iteritems()]
13248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13249 
 
13250 
  def __eq__(self, other):
13251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13252 
 
13253 
  def __ne__(self, other):
13254 
    return not (self == other)
13255 
 
13256 
class markOrdersAsLocalConnected_args:
13257 
  """
13258 
  Attributes:
13259 
   - providerId
13260 
   - local_connected_orders
13261 
  """
13262 
 
13263 
  thrift_spec = (
13264 
    None, # 0
13265 
    (1, TType.I64, 'providerId', None, None, ), # 1
13266 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13267 
  )
13268 
 
13269 
  def __init__(self, providerId=None, local_connected_orders=None,):
13270 
    self.providerId = providerId
13271 
    self.local_connected_orders = local_connected_orders
13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      if fid == 1:
13283 
        if ftype == TType.I64:
13284 
          self.providerId = iprot.readI64();
13285 
        else:
13286 
          iprot.skip(ftype)
13287 
      elif fid == 2:
13288 
        if ftype == TType.MAP:
13289 
          self.local_connected_orders = {}
5411 rajveer 13290 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
13291 
          for _i306 in xrange(_size302):
13292 
            _key307 = iprot.readString();
13293 
            _val308 = iprot.readString();
13294 
            self.local_connected_orders[_key307] = _val308
4910 phani.kuma 13295 
          iprot.readMapEnd()
13296 
        else:
13297 
          iprot.skip(ftype)
13298 
      else:
13299 
        iprot.skip(ftype)
13300 
      iprot.readFieldEnd()
13301 
    iprot.readStructEnd()
13302 
 
13303 
  def write(self, oprot):
13304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13306 
      return
13307 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
13308 
    if self.providerId is not None:
13309 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13310 
      oprot.writeI64(self.providerId)
13311 
      oprot.writeFieldEnd()
13312 
    if self.local_connected_orders is not None:
13313 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
13314 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5411 rajveer 13315 
      for kiter309,viter310 in self.local_connected_orders.items():
13316 
        oprot.writeString(kiter309)
13317 
        oprot.writeString(viter310)
4910 phani.kuma 13318 
      oprot.writeMapEnd()
13319 
      oprot.writeFieldEnd()
13320 
    oprot.writeFieldStop()
13321 
    oprot.writeStructEnd()
13322 
 
13323 
  def validate(self):
13324 
    return
13325 
 
13326 
 
13327 
  def __repr__(self):
13328 
    L = ['%s=%r' % (key, value)
13329 
      for key, value in self.__dict__.iteritems()]
13330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13331 
 
13332 
  def __eq__(self, other):
13333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13334 
 
13335 
  def __ne__(self, other):
13336 
    return not (self == other)
13337 
 
13338 
class markOrdersAsLocalConnected_result:
13339 
  """
13340 
  Attributes:
13341 
   - ex
13342 
  """
13343 
 
13344 
  thrift_spec = (
13345 
    None, # 0
13346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13347 
  )
13348 
 
13349 
  def __init__(self, ex=None,):
13350 
    self.ex = ex
13351 
 
13352 
  def read(self, iprot):
13353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13355 
      return
13356 
    iprot.readStructBegin()
13357 
    while True:
13358 
      (fname, ftype, fid) = iprot.readFieldBegin()
13359 
      if ftype == TType.STOP:
13360 
        break
13361 
      if fid == 1:
3064 chandransh 13362 
        if ftype == TType.STRUCT:
13363 
          self.ex = TransactionServiceException()
13364 
          self.ex.read(iprot)
1627 ankur.sing 13365 
        else:
13366 
          iprot.skip(ftype)
13367 
      else:
13368 
        iprot.skip(ftype)
13369 
      iprot.readFieldEnd()
13370 
    iprot.readStructEnd()
13371 
 
13372 
  def write(self, oprot):
13373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13375 
      return
4910 phani.kuma 13376 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13377 
    if self.ex is not None:
13378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13379 
      self.ex.write(oprot)
13380 
      oprot.writeFieldEnd()
13381 
    oprot.writeFieldStop()
13382 
    oprot.writeStructEnd()
13383 
 
13384 
  def validate(self):
13385 
    return
13386 
 
13387 
 
13388 
  def __repr__(self):
13389 
    L = ['%s=%r' % (key, value)
13390 
      for key, value in self.__dict__.iteritems()]
13391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13392 
 
13393 
  def __eq__(self, other):
13394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13395 
 
13396 
  def __ne__(self, other):
13397 
    return not (self == other)
13398 
 
13399 
class getOrdersNotLocalConnected_args:
13400 
  """
13401 
  Attributes:
13402 
   - providerId
13403 
  """
13404 
 
13405 
  thrift_spec = (
13406 
    None, # 0
13407 
    (1, TType.I64, 'providerId', None, None, ), # 1
13408 
  )
13409 
 
13410 
  def __init__(self, providerId=None,):
13411 
    self.providerId = providerId
13412 
 
13413 
  def read(self, iprot):
13414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13416 
      return
13417 
    iprot.readStructBegin()
13418 
    while True:
13419 
      (fname, ftype, fid) = iprot.readFieldBegin()
13420 
      if ftype == TType.STOP:
13421 
        break
13422 
      if fid == 1:
13423 
        if ftype == TType.I64:
13424 
          self.providerId = iprot.readI64();
13425 
        else:
13426 
          iprot.skip(ftype)
13427 
      else:
13428 
        iprot.skip(ftype)
13429 
      iprot.readFieldEnd()
13430 
    iprot.readStructEnd()
13431 
 
13432 
  def write(self, oprot):
13433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13435 
      return
13436 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13437 
    if self.providerId is not None:
13438 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13439 
      oprot.writeI64(self.providerId)
13440 
      oprot.writeFieldEnd()
13441 
    oprot.writeFieldStop()
13442 
    oprot.writeStructEnd()
13443 
 
13444 
  def validate(self):
13445 
    return
13446 
 
13447 
 
13448 
  def __repr__(self):
13449 
    L = ['%s=%r' % (key, value)
13450 
      for key, value in self.__dict__.iteritems()]
13451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13452 
 
13453 
  def __eq__(self, other):
13454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13455 
 
13456 
  def __ne__(self, other):
13457 
    return not (self == other)
13458 
 
13459 
class getOrdersNotLocalConnected_result:
13460 
  """
13461 
  Attributes:
13462 
   - success
13463 
  """
13464 
 
13465 
  thrift_spec = (
13466 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13467 
  )
13468 
 
13469 
  def __init__(self, success=None,):
13470 
    self.success = success
13471 
 
13472 
  def read(self, iprot):
13473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13475 
      return
13476 
    iprot.readStructBegin()
13477 
    while True:
13478 
      (fname, ftype, fid) = iprot.readFieldBegin()
13479 
      if ftype == TType.STOP:
13480 
        break
13481 
      if fid == 0:
13482 
        if ftype == TType.LIST:
13483 
          self.success = []
5411 rajveer 13484 
          (_etype314, _size311) = iprot.readListBegin()
13485 
          for _i315 in xrange(_size311):
13486 
            _elem316 = Order()
13487 
            _elem316.read(iprot)
13488 
            self.success.append(_elem316)
4910 phani.kuma 13489 
          iprot.readListEnd()
13490 
        else:
13491 
          iprot.skip(ftype)
13492 
      else:
13493 
        iprot.skip(ftype)
13494 
      iprot.readFieldEnd()
13495 
    iprot.readStructEnd()
13496 
 
13497 
  def write(self, oprot):
13498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13500 
      return
13501 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13502 
    if self.success is not None:
13503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13504 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13505 
      for iter317 in self.success:
13506 
        iter317.write(oprot)
4581 phani.kuma 13507 
      oprot.writeListEnd()
13508 
      oprot.writeFieldEnd()
4910 phani.kuma 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 markOrdersAsDestinationCityReached_args:
13528 
  """
13529 
  Attributes:
13530 
   - providerId
13531 
   - destination_city_reached_orders
13532 
  """
13533 
 
13534 
  thrift_spec = (
13535 
    None, # 0
13536 
    (1, TType.I64, 'providerId', None, None, ), # 1
13537 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13538 
  )
13539 
 
13540 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13541 
    self.providerId = providerId
13542 
    self.destination_city_reached_orders = destination_city_reached_orders
13543 
 
13544 
  def read(self, iprot):
13545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13547 
      return
13548 
    iprot.readStructBegin()
13549 
    while True:
13550 
      (fname, ftype, fid) = iprot.readFieldBegin()
13551 
      if ftype == TType.STOP:
13552 
        break
13553 
      if fid == 1:
13554 
        if ftype == TType.I64:
13555 
          self.providerId = iprot.readI64();
13556 
        else:
13557 
          iprot.skip(ftype)
13558 
      elif fid == 2:
13559 
        if ftype == TType.MAP:
13560 
          self.destination_city_reached_orders = {}
5411 rajveer 13561 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
13562 
          for _i322 in xrange(_size318):
13563 
            _key323 = iprot.readString();
13564 
            _val324 = iprot.readString();
13565 
            self.destination_city_reached_orders[_key323] = _val324
4910 phani.kuma 13566 
          iprot.readMapEnd()
13567 
        else:
13568 
          iprot.skip(ftype)
13569 
      else:
13570 
        iprot.skip(ftype)
13571 
      iprot.readFieldEnd()
13572 
    iprot.readStructEnd()
13573 
 
13574 
  def write(self, oprot):
13575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13577 
      return
13578 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13579 
    if self.providerId is not None:
13580 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13581 
      oprot.writeI64(self.providerId)
13582 
      oprot.writeFieldEnd()
13583 
    if self.destination_city_reached_orders is not None:
13584 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13585 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5411 rajveer 13586 
      for kiter325,viter326 in self.destination_city_reached_orders.items():
13587 
        oprot.writeString(kiter325)
13588 
        oprot.writeString(viter326)
4910 phani.kuma 13589 
      oprot.writeMapEnd()
13590 
      oprot.writeFieldEnd()
13591 
    oprot.writeFieldStop()
13592 
    oprot.writeStructEnd()
13593 
 
13594 
  def validate(self):
13595 
    return
13596 
 
13597 
 
13598 
  def __repr__(self):
13599 
    L = ['%s=%r' % (key, value)
13600 
      for key, value in self.__dict__.iteritems()]
13601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13602 
 
13603 
  def __eq__(self, other):
13604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13605 
 
13606 
  def __ne__(self, other):
13607 
    return not (self == other)
13608 
 
13609 
class markOrdersAsDestinationCityReached_result:
13610 
  """
13611 
  Attributes:
13612 
   - ex
13613 
  """
13614 
 
13615 
  thrift_spec = (
13616 
    None, # 0
13617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13618 
  )
13619 
 
13620 
  def __init__(self, ex=None,):
13621 
    self.ex = ex
13622 
 
13623 
  def read(self, iprot):
13624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13626 
      return
13627 
    iprot.readStructBegin()
13628 
    while True:
13629 
      (fname, ftype, fid) = iprot.readFieldBegin()
13630 
      if ftype == TType.STOP:
13631 
        break
13632 
      if fid == 1:
13633 
        if ftype == TType.STRUCT:
13634 
          self.ex = TransactionServiceException()
13635 
          self.ex.read(iprot)
13636 
        else:
13637 
          iprot.skip(ftype)
13638 
      else:
13639 
        iprot.skip(ftype)
13640 
      iprot.readFieldEnd()
13641 
    iprot.readStructEnd()
13642 
 
13643 
  def write(self, oprot):
13644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13646 
      return
13647 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13648 
    if self.ex is not None:
3064 chandransh 13649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13650 
      self.ex.write(oprot)
1627 ankur.sing 13651 
      oprot.writeFieldEnd()
13652 
    oprot.writeFieldStop()
13653 
    oprot.writeStructEnd()
13654 
 
3431 rajveer 13655 
  def validate(self):
13656 
    return
13657 
 
13658 
 
1627 ankur.sing 13659 
  def __repr__(self):
13660 
    L = ['%s=%r' % (key, value)
13661 
      for key, value in self.__dict__.iteritems()]
13662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13663 
 
13664 
  def __eq__(self, other):
13665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13666 
 
13667 
  def __ne__(self, other):
13668 
    return not (self == other)
13669 
 
4910 phani.kuma 13670 
class markOrdersAsFirstDeliveryAttempted_args:
13671 
  """
13672 
  Attributes:
13673 
   - providerId
13674 
   - first_atdl_orders
13675 
  """
13676 
 
13677 
  thrift_spec = (
13678 
    None, # 0
13679 
    (1, TType.I64, 'providerId', None, None, ), # 1
13680 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13681 
  )
13682 
 
13683 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13684 
    self.providerId = providerId
13685 
    self.first_atdl_orders = first_atdl_orders
13686 
 
13687 
  def read(self, iprot):
13688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13690 
      return
13691 
    iprot.readStructBegin()
13692 
    while True:
13693 
      (fname, ftype, fid) = iprot.readFieldBegin()
13694 
      if ftype == TType.STOP:
13695 
        break
13696 
      if fid == 1:
13697 
        if ftype == TType.I64:
13698 
          self.providerId = iprot.readI64();
13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      elif fid == 2:
13702 
        if ftype == TType.MAP:
13703 
          self.first_atdl_orders = {}
5411 rajveer 13704 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
13705 
          for _i331 in xrange(_size327):
13706 
            _key332 = iprot.readString();
13707 
            _val333 = iprot.readString();
13708 
            self.first_atdl_orders[_key332] = _val333
4910 phani.kuma 13709 
          iprot.readMapEnd()
13710 
        else:
13711 
          iprot.skip(ftype)
13712 
      else:
13713 
        iprot.skip(ftype)
13714 
      iprot.readFieldEnd()
13715 
    iprot.readStructEnd()
13716 
 
13717 
  def write(self, oprot):
13718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13720 
      return
13721 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13722 
    if self.providerId is not None:
13723 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13724 
      oprot.writeI64(self.providerId)
13725 
      oprot.writeFieldEnd()
13726 
    if self.first_atdl_orders is not None:
13727 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13728 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5411 rajveer 13729 
      for kiter334,viter335 in self.first_atdl_orders.items():
13730 
        oprot.writeString(kiter334)
13731 
        oprot.writeString(viter335)
4910 phani.kuma 13732 
      oprot.writeMapEnd()
13733 
      oprot.writeFieldEnd()
13734 
    oprot.writeFieldStop()
13735 
    oprot.writeStructEnd()
13736 
 
13737 
  def validate(self):
13738 
    return
13739 
 
13740 
 
13741 
  def __repr__(self):
13742 
    L = ['%s=%r' % (key, value)
13743 
      for key, value in self.__dict__.iteritems()]
13744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13745 
 
13746 
  def __eq__(self, other):
13747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13748 
 
13749 
  def __ne__(self, other):
13750 
    return not (self == other)
13751 
 
13752 
class markOrdersAsFirstDeliveryAttempted_result:
13753 
  """
13754 
  Attributes:
13755 
   - ex
13756 
  """
13757 
 
13758 
  thrift_spec = (
13759 
    None, # 0
13760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13761 
  )
13762 
 
13763 
  def __init__(self, ex=None,):
13764 
    self.ex = ex
13765 
 
13766 
  def read(self, iprot):
13767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13769 
      return
13770 
    iprot.readStructBegin()
13771 
    while True:
13772 
      (fname, ftype, fid) = iprot.readFieldBegin()
13773 
      if ftype == TType.STOP:
13774 
        break
13775 
      if fid == 1:
13776 
        if ftype == TType.STRUCT:
13777 
          self.ex = TransactionServiceException()
13778 
          self.ex.read(iprot)
13779 
        else:
13780 
          iprot.skip(ftype)
13781 
      else:
13782 
        iprot.skip(ftype)
13783 
      iprot.readFieldEnd()
13784 
    iprot.readStructEnd()
13785 
 
13786 
  def write(self, oprot):
13787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13789 
      return
13790 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13791 
    if self.ex is not None:
13792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13793 
      self.ex.write(oprot)
13794 
      oprot.writeFieldEnd()
13795 
    oprot.writeFieldStop()
13796 
    oprot.writeStructEnd()
13797 
 
13798 
  def validate(self):
13799 
    return
13800 
 
13801 
 
13802 
  def __repr__(self):
13803 
    L = ['%s=%r' % (key, value)
13804 
      for key, value in self.__dict__.iteritems()]
13805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13806 
 
13807 
  def __eq__(self, other):
13808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13809 
 
13810 
  def __ne__(self, other):
13811 
    return not (self == other)
13812 
 
3064 chandransh 13813 
class getUndeliveredOrders_args:
1886 ankur.sing 13814 
  """
13815 
  Attributes:
3064 chandransh 13816 
   - providerId
13817 
   - warehouseId
1886 ankur.sing 13818 
  """
1627 ankur.sing 13819 
 
1886 ankur.sing 13820 
  thrift_spec = (
13821 
    None, # 0
3064 chandransh 13822 
    (1, TType.I64, 'providerId', None, None, ), # 1
13823 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13824 
  )
13825 
 
3064 chandransh 13826 
  def __init__(self, providerId=None, warehouseId=None,):
13827 
    self.providerId = providerId
13828 
    self.warehouseId = warehouseId
1886 ankur.sing 13829 
 
13830 
  def read(self, iprot):
13831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13833 
      return
13834 
    iprot.readStructBegin()
13835 
    while True:
13836 
      (fname, ftype, fid) = iprot.readFieldBegin()
13837 
      if ftype == TType.STOP:
13838 
        break
13839 
      if fid == 1:
13840 
        if ftype == TType.I64:
3064 chandransh 13841 
          self.providerId = iprot.readI64();
1886 ankur.sing 13842 
        else:
13843 
          iprot.skip(ftype)
3064 chandransh 13844 
      elif fid == 2:
13845 
        if ftype == TType.I64:
13846 
          self.warehouseId = iprot.readI64();
13847 
        else:
13848 
          iprot.skip(ftype)
1886 ankur.sing 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
3064 chandransh 13858 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13859 
    if self.providerId is not None:
3064 chandransh 13860 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13861 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13862 
      oprot.writeFieldEnd()
3431 rajveer 13863 
    if self.warehouseId is not None:
3064 chandransh 13864 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13865 
      oprot.writeI64(self.warehouseId)
13866 
      oprot.writeFieldEnd()
1886 ankur.sing 13867 
    oprot.writeFieldStop()
13868 
    oprot.writeStructEnd()
13869 
 
3431 rajveer 13870 
  def validate(self):
13871 
    return
13872 
 
13873 
 
1886 ankur.sing 13874 
  def __repr__(self):
13875 
    L = ['%s=%r' % (key, value)
13876 
      for key, value in self.__dict__.iteritems()]
13877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13878 
 
13879 
  def __eq__(self, other):
13880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13881 
 
13882 
  def __ne__(self, other):
13883 
    return not (self == other)
13884 
 
3064 chandransh 13885 
class getUndeliveredOrders_result:
1886 ankur.sing 13886 
  """
13887 
  Attributes:
13888 
   - success
13889 
  """
13890 
 
13891 
  thrift_spec = (
13892 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13893 
  )
13894 
 
13895 
  def __init__(self, success=None,):
13896 
    self.success = success
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 == 0:
13908 
        if ftype == TType.LIST:
13909 
          self.success = []
5411 rajveer 13910 
          (_etype339, _size336) = iprot.readListBegin()
13911 
          for _i340 in xrange(_size336):
13912 
            _elem341 = Order()
13913 
            _elem341.read(iprot)
13914 
            self.success.append(_elem341)
1886 ankur.sing 13915 
          iprot.readListEnd()
13916 
        else:
13917 
          iprot.skip(ftype)
13918 
      else:
13919 
        iprot.skip(ftype)
13920 
      iprot.readFieldEnd()
13921 
    iprot.readStructEnd()
13922 
 
13923 
  def write(self, oprot):
13924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13926 
      return
3064 chandransh 13927 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13928 
    if self.success is not None:
1886 ankur.sing 13929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 13931 
      for iter342 in self.success:
13932 
        iter342.write(oprot)
1886 ankur.sing 13933 
      oprot.writeListEnd()
13934 
      oprot.writeFieldEnd()
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 
 
4783 phani.kuma 13953 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13954 
 
13955 
  thrift_spec = (
13956 
  )
13957 
 
13958 
  def read(self, iprot):
13959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13961 
      return
13962 
    iprot.readStructBegin()
13963 
    while True:
13964 
      (fname, ftype, fid) = iprot.readFieldBegin()
13965 
      if ftype == TType.STOP:
13966 
        break
13967 
      else:
13968 
        iprot.skip(ftype)
13969 
      iprot.readFieldEnd()
13970 
    iprot.readStructEnd()
13971 
 
13972 
  def write(self, oprot):
13973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13975 
      return
13976 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13977 
    oprot.writeFieldStop()
13978 
    oprot.writeStructEnd()
13979 
 
13980 
  def validate(self):
13981 
    return
13982 
 
13983 
 
13984 
  def __repr__(self):
13985 
    L = ['%s=%r' % (key, value)
13986 
      for key, value in self.__dict__.iteritems()]
13987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13988 
 
13989 
  def __eq__(self, other):
13990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13991 
 
13992 
  def __ne__(self, other):
13993 
    return not (self == other)
13994 
 
13995 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13996 
  """
13997 
  Attributes:
13998 
   - success
13999 
  """
14000 
 
14001 
  thrift_spec = (
14002 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14003 
  )
14004 
 
14005 
  def __init__(self, success=None,):
14006 
    self.success = success
14007 
 
14008 
  def read(self, iprot):
14009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14011 
      return
14012 
    iprot.readStructBegin()
14013 
    while True:
14014 
      (fname, ftype, fid) = iprot.readFieldBegin()
14015 
      if ftype == TType.STOP:
14016 
        break
14017 
      if fid == 0:
14018 
        if ftype == TType.LIST:
14019 
          self.success = []
5411 rajveer 14020 
          (_etype346, _size343) = iprot.readListBegin()
14021 
          for _i347 in xrange(_size343):
14022 
            _elem348 = Order()
14023 
            _elem348.read(iprot)
14024 
            self.success.append(_elem348)
4783 phani.kuma 14025 
          iprot.readListEnd()
14026 
        else:
14027 
          iprot.skip(ftype)
14028 
      else:
14029 
        iprot.skip(ftype)
14030 
      iprot.readFieldEnd()
14031 
    iprot.readStructEnd()
14032 
 
14033 
  def write(self, oprot):
14034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14036 
      return
14037 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14038 
    if self.success is not None:
14039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14040 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 14041 
      for iter349 in self.success:
14042 
        iter349.write(oprot)
4783 phani.kuma 14043 
      oprot.writeListEnd()
14044 
      oprot.writeFieldEnd()
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 
 
2536 chandransh 14063 
class toggleDOAFlag_args:
14064 
  """
14065 
  Attributes:
14066 
   - orderId
14067 
  """
1886 ankur.sing 14068 
 
2536 chandransh 14069 
  thrift_spec = (
14070 
    None, # 0
14071 
    (1, TType.I64, 'orderId', None, None, ), # 1
14072 
  )
14073 
 
14074 
  def __init__(self, orderId=None,):
14075 
    self.orderId = orderId
14076 
 
14077 
  def read(self, iprot):
14078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14080 
      return
14081 
    iprot.readStructBegin()
14082 
    while True:
14083 
      (fname, ftype, fid) = iprot.readFieldBegin()
14084 
      if ftype == TType.STOP:
14085 
        break
14086 
      if fid == 1:
14087 
        if ftype == TType.I64:
14088 
          self.orderId = iprot.readI64();
14089 
        else:
14090 
          iprot.skip(ftype)
14091 
      else:
14092 
        iprot.skip(ftype)
14093 
      iprot.readFieldEnd()
14094 
    iprot.readStructEnd()
14095 
 
14096 
  def write(self, oprot):
14097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14099 
      return
14100 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14101 
    if self.orderId is not None:
2536 chandransh 14102 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14103 
      oprot.writeI64(self.orderId)
14104 
      oprot.writeFieldEnd()
14105 
    oprot.writeFieldStop()
14106 
    oprot.writeStructEnd()
14107 
 
3431 rajveer 14108 
  def validate(self):
14109 
    return
14110 
 
14111 
 
2536 chandransh 14112 
  def __repr__(self):
14113 
    L = ['%s=%r' % (key, value)
14114 
      for key, value in self.__dict__.iteritems()]
14115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14116 
 
14117 
  def __eq__(self, other):
14118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14119 
 
14120 
  def __ne__(self, other):
14121 
    return not (self == other)
14122 
 
14123 
class toggleDOAFlag_result:
14124 
  """
14125 
  Attributes:
14126 
   - success
14127 
   - ex
14128 
  """
14129 
 
14130 
  thrift_spec = (
14131 
    (0, TType.BOOL, 'success', None, None, ), # 0
14132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14133 
  )
14134 
 
14135 
  def __init__(self, success=None, ex=None,):
14136 
    self.success = success
14137 
    self.ex = ex
14138 
 
14139 
  def read(self, iprot):
14140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14142 
      return
14143 
    iprot.readStructBegin()
14144 
    while True:
14145 
      (fname, ftype, fid) = iprot.readFieldBegin()
14146 
      if ftype == TType.STOP:
14147 
        break
14148 
      if fid == 0:
14149 
        if ftype == TType.BOOL:
14150 
          self.success = iprot.readBool();
14151 
        else:
14152 
          iprot.skip(ftype)
14153 
      elif fid == 1:
14154 
        if ftype == TType.STRUCT:
14155 
          self.ex = TransactionServiceException()
14156 
          self.ex.read(iprot)
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_result')
3431 rajveer 14169 
    if self.success is not None:
2536 chandransh 14170 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14171 
      oprot.writeBool(self.success)
14172 
      oprot.writeFieldEnd()
3431 rajveer 14173 
    if self.ex is not None:
2536 chandransh 14174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14175 
      self.ex.write(oprot)
14176 
      oprot.writeFieldEnd()
14177 
    oprot.writeFieldStop()
14178 
    oprot.writeStructEnd()
14179 
 
3431 rajveer 14180 
  def validate(self):
14181 
    return
14182 
 
14183 
 
2536 chandransh 14184 
  def __repr__(self):
14185 
    L = ['%s=%r' % (key, value)
14186 
      for key, value in self.__dict__.iteritems()]
14187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14188 
 
14189 
  def __eq__(self, other):
14190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14191 
 
14192 
  def __ne__(self, other):
14193 
    return not (self == other)
14194 
 
4712 rajveer 14195 
class markOrderAsDelivered_args:
14196 
  """
14197 
  Attributes:
14198 
   - orderId
14199 
   - deliveryTimestamp
14200 
   - receiver
14201 
  """
14202 
 
14203 
  thrift_spec = None
14204 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14205 
    self.orderId = orderId
14206 
    self.deliveryTimestamp = deliveryTimestamp
14207 
    self.receiver = receiver
14208 
 
14209 
  def read(self, iprot):
14210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14212 
      return
14213 
    iprot.readStructBegin()
14214 
    while True:
14215 
      (fname, ftype, fid) = iprot.readFieldBegin()
14216 
      if ftype == TType.STOP:
14217 
        break
14218 
      if fid == 1:
14219 
        if ftype == TType.I64:
14220 
          self.orderId = iprot.readI64();
14221 
        else:
14222 
          iprot.skip(ftype)
14223 
      elif fid == 2:
14224 
        if ftype == TType.I64:
14225 
          self.deliveryTimestamp = iprot.readI64();
14226 
        else:
14227 
          iprot.skip(ftype)
14228 
      elif fid == -1:
14229 
        if ftype == TType.STRING:
14230 
          self.receiver = iprot.readString();
14231 
        else:
14232 
          iprot.skip(ftype)
14233 
      else:
14234 
        iprot.skip(ftype)
14235 
      iprot.readFieldEnd()
14236 
    iprot.readStructEnd()
14237 
 
14238 
  def write(self, oprot):
14239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14241 
      return
14242 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14243 
    if self.receiver is not None:
14244 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14245 
      oprot.writeString(self.receiver)
14246 
      oprot.writeFieldEnd()
14247 
    if self.orderId is not None:
14248 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14249 
      oprot.writeI64(self.orderId)
14250 
      oprot.writeFieldEnd()
14251 
    if self.deliveryTimestamp is not None:
14252 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
14253 
      oprot.writeI64(self.deliveryTimestamp)
14254 
      oprot.writeFieldEnd()
14255 
    oprot.writeFieldStop()
14256 
    oprot.writeStructEnd()
14257 
 
14258 
  def validate(self):
14259 
    return
14260 
 
14261 
 
14262 
  def __repr__(self):
14263 
    L = ['%s=%r' % (key, value)
14264 
      for key, value in self.__dict__.iteritems()]
14265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14266 
 
14267 
  def __eq__(self, other):
14268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14269 
 
14270 
  def __ne__(self, other):
14271 
    return not (self == other)
14272 
 
14273 
class markOrderAsDelivered_result:
14274 
  """
14275 
  Attributes:
14276 
   - ex
14277 
  """
14278 
 
14279 
  thrift_spec = (
14280 
    None, # 0
14281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14282 
  )
14283 
 
14284 
  def __init__(self, ex=None,):
14285 
    self.ex = ex
14286 
 
14287 
  def read(self, iprot):
14288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14290 
      return
14291 
    iprot.readStructBegin()
14292 
    while True:
14293 
      (fname, ftype, fid) = iprot.readFieldBegin()
14294 
      if ftype == TType.STOP:
14295 
        break
14296 
      if fid == 1:
14297 
        if ftype == TType.STRUCT:
14298 
          self.ex = TransactionServiceException()
14299 
          self.ex.read(iprot)
14300 
        else:
14301 
          iprot.skip(ftype)
14302 
      else:
14303 
        iprot.skip(ftype)
14304 
      iprot.readFieldEnd()
14305 
    iprot.readStructEnd()
14306 
 
14307 
  def write(self, oprot):
14308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14310 
      return
14311 
    oprot.writeStructBegin('markOrderAsDelivered_result')
14312 
    if self.ex is not None:
14313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14314 
      self.ex.write(oprot)
14315 
      oprot.writeFieldEnd()
14316 
    oprot.writeFieldStop()
14317 
    oprot.writeStructEnd()
14318 
 
14319 
  def validate(self):
14320 
    return
14321 
 
14322 
 
14323 
  def __repr__(self):
14324 
    L = ['%s=%r' % (key, value)
14325 
      for key, value in self.__dict__.iteritems()]
14326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14327 
 
14328 
  def __eq__(self, other):
14329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14330 
 
14331 
  def __ne__(self, other):
14332 
    return not (self == other)
14333 
 
4454 rajveer 14334 
class markOrderDoaRequestReceived_args:
14335 
  """
14336 
  Attributes:
14337 
   - orderId
14338 
  """
14339 
 
14340 
  thrift_spec = (
14341 
    None, # 0
14342 
    (1, TType.I64, 'orderId', None, None, ), # 1
14343 
  )
14344 
 
14345 
  def __init__(self, orderId=None,):
14346 
    self.orderId = orderId
14347 
 
14348 
  def read(self, iprot):
14349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14351 
      return
14352 
    iprot.readStructBegin()
14353 
    while True:
14354 
      (fname, ftype, fid) = iprot.readFieldBegin()
14355 
      if ftype == TType.STOP:
14356 
        break
14357 
      if fid == 1:
14358 
        if ftype == TType.I64:
14359 
          self.orderId = iprot.readI64();
14360 
        else:
14361 
          iprot.skip(ftype)
14362 
      else:
14363 
        iprot.skip(ftype)
14364 
      iprot.readFieldEnd()
14365 
    iprot.readStructEnd()
14366 
 
14367 
  def write(self, oprot):
14368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14370 
      return
14371 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14372 
    if self.orderId is not None:
14373 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14374 
      oprot.writeI64(self.orderId)
14375 
      oprot.writeFieldEnd()
14376 
    oprot.writeFieldStop()
14377 
    oprot.writeStructEnd()
14378 
 
14379 
  def validate(self):
14380 
    return
14381 
 
14382 
 
14383 
  def __repr__(self):
14384 
    L = ['%s=%r' % (key, value)
14385 
      for key, value in self.__dict__.iteritems()]
14386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14387 
 
14388 
  def __eq__(self, other):
14389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14390 
 
14391 
  def __ne__(self, other):
14392 
    return not (self == other)
14393 
 
14394 
class markOrderDoaRequestReceived_result:
14395 
  """
14396 
  Attributes:
14397 
   - success
14398 
   - ex
14399 
  """
14400 
 
14401 
  thrift_spec = (
14402 
    (0, TType.BOOL, 'success', None, None, ), # 0
14403 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14404 
  )
14405 
 
14406 
  def __init__(self, success=None, ex=None,):
14407 
    self.success = success
14408 
    self.ex = ex
14409 
 
14410 
  def read(self, iprot):
14411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14413 
      return
14414 
    iprot.readStructBegin()
14415 
    while True:
14416 
      (fname, ftype, fid) = iprot.readFieldBegin()
14417 
      if ftype == TType.STOP:
14418 
        break
14419 
      if fid == 0:
14420 
        if ftype == TType.BOOL:
14421 
          self.success = iprot.readBool();
14422 
        else:
14423 
          iprot.skip(ftype)
14424 
      elif fid == 1:
14425 
        if ftype == TType.STRUCT:
14426 
          self.ex = TransactionServiceException()
14427 
          self.ex.read(iprot)
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_result')
14440 
    if self.success is not None:
14441 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14442 
      oprot.writeBool(self.success)
14443 
      oprot.writeFieldEnd()
14444 
    if self.ex is not None:
14445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14446 
      self.ex.write(oprot)
14447 
      oprot.writeFieldEnd()
14448 
    oprot.writeFieldStop()
14449 
    oprot.writeStructEnd()
14450 
 
14451 
  def validate(self):
14452 
    return
14453 
 
14454 
 
14455 
  def __repr__(self):
14456 
    L = ['%s=%r' % (key, value)
14457 
      for key, value in self.__dict__.iteritems()]
14458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14459 
 
14460 
  def __eq__(self, other):
14461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14462 
 
14463 
  def __ne__(self, other):
14464 
    return not (self == other)
14465 
 
14466 
class markOrderDoaRequestAuthorized_args:
14467 
  """
14468 
  Attributes:
14469 
   - orderId
14470 
   - isAuthorized
14471 
  """
14472 
 
14473 
  thrift_spec = (
14474 
    None, # 0
14475 
    (1, TType.I64, 'orderId', None, None, ), # 1
14476 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14477 
  )
14478 
 
14479 
  def __init__(self, orderId=None, isAuthorized=None,):
14480 
    self.orderId = orderId
14481 
    self.isAuthorized = isAuthorized
14482 
 
14483 
  def read(self, iprot):
14484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14486 
      return
14487 
    iprot.readStructBegin()
14488 
    while True:
14489 
      (fname, ftype, fid) = iprot.readFieldBegin()
14490 
      if ftype == TType.STOP:
14491 
        break
14492 
      if fid == 1:
14493 
        if ftype == TType.I64:
14494 
          self.orderId = iprot.readI64();
14495 
        else:
14496 
          iprot.skip(ftype)
14497 
      elif fid == 2:
14498 
        if ftype == TType.BOOL:
14499 
          self.isAuthorized = iprot.readBool();
14500 
        else:
14501 
          iprot.skip(ftype)
14502 
      else:
14503 
        iprot.skip(ftype)
14504 
      iprot.readFieldEnd()
14505 
    iprot.readStructEnd()
14506 
 
14507 
  def write(self, oprot):
14508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14510 
      return
14511 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14512 
    if self.orderId is not None:
14513 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14514 
      oprot.writeI64(self.orderId)
14515 
      oprot.writeFieldEnd()
14516 
    if self.isAuthorized is not None:
14517 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14518 
      oprot.writeBool(self.isAuthorized)
14519 
      oprot.writeFieldEnd()
14520 
    oprot.writeFieldStop()
14521 
    oprot.writeStructEnd()
14522 
 
14523 
  def validate(self):
14524 
    return
14525 
 
14526 
 
14527 
  def __repr__(self):
14528 
    L = ['%s=%r' % (key, value)
14529 
      for key, value in self.__dict__.iteritems()]
14530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14531 
 
14532 
  def __eq__(self, other):
14533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14534 
 
14535 
  def __ne__(self, other):
14536 
    return not (self == other)
14537 
 
14538 
class markOrderDoaRequestAuthorized_result:
14539 
  """
14540 
  Attributes:
14541 
   - success
14542 
   - ex
14543 
  """
14544 
 
14545 
  thrift_spec = (
14546 
    (0, TType.BOOL, 'success', None, None, ), # 0
14547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14548 
  )
14549 
 
14550 
  def __init__(self, success=None, ex=None,):
14551 
    self.success = success
14552 
    self.ex = ex
14553 
 
14554 
  def read(self, iprot):
14555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14557 
      return
14558 
    iprot.readStructBegin()
14559 
    while True:
14560 
      (fname, ftype, fid) = iprot.readFieldBegin()
14561 
      if ftype == TType.STOP:
14562 
        break
14563 
      if fid == 0:
14564 
        if ftype == TType.BOOL:
14565 
          self.success = iprot.readBool();
14566 
        else:
14567 
          iprot.skip(ftype)
14568 
      elif fid == 1:
14569 
        if ftype == TType.STRUCT:
14570 
          self.ex = TransactionServiceException()
14571 
          self.ex.read(iprot)
14572 
        else:
14573 
          iprot.skip(ftype)
14574 
      else:
14575 
        iprot.skip(ftype)
14576 
      iprot.readFieldEnd()
14577 
    iprot.readStructEnd()
14578 
 
14579 
  def write(self, oprot):
14580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14582 
      return
14583 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14584 
    if self.success is not None:
14585 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14586 
      oprot.writeBool(self.success)
14587 
      oprot.writeFieldEnd()
14588 
    if self.ex is not None:
14589 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14590 
      self.ex.write(oprot)
14591 
      oprot.writeFieldEnd()
14592 
    oprot.writeFieldStop()
14593 
    oprot.writeStructEnd()
14594 
 
14595 
  def validate(self):
14596 
    return
14597 
 
14598 
 
14599 
  def __repr__(self):
14600 
    L = ['%s=%r' % (key, value)
14601 
      for key, value in self.__dict__.iteritems()]
14602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14603 
 
14604 
  def __eq__(self, other):
14605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14606 
 
14607 
  def __ne__(self, other):
14608 
    return not (self == other)
14609 
 
4488 rajveer 14610 
class markOrderReturnRequestReceived_args:
14611 
  """
14612 
  Attributes:
14613 
   - orderId
14614 
  """
14615 
 
14616 
  thrift_spec = (
14617 
    None, # 0
14618 
    (1, TType.I64, 'orderId', None, None, ), # 1
14619 
  )
14620 
 
14621 
  def __init__(self, orderId=None,):
14622 
    self.orderId = orderId
14623 
 
14624 
  def read(self, iprot):
14625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14627 
      return
14628 
    iprot.readStructBegin()
14629 
    while True:
14630 
      (fname, ftype, fid) = iprot.readFieldBegin()
14631 
      if ftype == TType.STOP:
14632 
        break
14633 
      if fid == 1:
14634 
        if ftype == TType.I64:
14635 
          self.orderId = iprot.readI64();
14636 
        else:
14637 
          iprot.skip(ftype)
14638 
      else:
14639 
        iprot.skip(ftype)
14640 
      iprot.readFieldEnd()
14641 
    iprot.readStructEnd()
14642 
 
14643 
  def write(self, oprot):
14644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14646 
      return
14647 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14648 
    if self.orderId is not None:
14649 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14650 
      oprot.writeI64(self.orderId)
14651 
      oprot.writeFieldEnd()
14652 
    oprot.writeFieldStop()
14653 
    oprot.writeStructEnd()
14654 
 
14655 
  def validate(self):
14656 
    return
14657 
 
14658 
 
14659 
  def __repr__(self):
14660 
    L = ['%s=%r' % (key, value)
14661 
      for key, value in self.__dict__.iteritems()]
14662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14663 
 
14664 
  def __eq__(self, other):
14665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14666 
 
14667 
  def __ne__(self, other):
14668 
    return not (self == other)
14669 
 
14670 
class markOrderReturnRequestReceived_result:
14671 
  """
14672 
  Attributes:
14673 
   - success
14674 
   - ex
14675 
  """
14676 
 
14677 
  thrift_spec = (
14678 
    (0, TType.BOOL, 'success', None, None, ), # 0
14679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14680 
  )
14681 
 
14682 
  def __init__(self, success=None, ex=None,):
14683 
    self.success = success
14684 
    self.ex = ex
14685 
 
14686 
  def read(self, iprot):
14687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14689 
      return
14690 
    iprot.readStructBegin()
14691 
    while True:
14692 
      (fname, ftype, fid) = iprot.readFieldBegin()
14693 
      if ftype == TType.STOP:
14694 
        break
14695 
      if fid == 0:
14696 
        if ftype == TType.BOOL:
14697 
          self.success = iprot.readBool();
14698 
        else:
14699 
          iprot.skip(ftype)
14700 
      elif fid == 1:
14701 
        if ftype == TType.STRUCT:
14702 
          self.ex = TransactionServiceException()
14703 
          self.ex.read(iprot)
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_result')
14716 
    if self.success is not None:
14717 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14718 
      oprot.writeBool(self.success)
14719 
      oprot.writeFieldEnd()
14720 
    if self.ex is not None:
14721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14722 
      self.ex.write(oprot)
14723 
      oprot.writeFieldEnd()
14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
14741 
 
14742 
class markOrderReturnRequestAuthorized_args:
14743 
  """
14744 
  Attributes:
14745 
   - orderId
14746 
   - isAuthorized
14747 
  """
14748 
 
14749 
  thrift_spec = (
14750 
    None, # 0
14751 
    (1, TType.I64, 'orderId', None, None, ), # 1
14752 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14753 
  )
14754 
 
14755 
  def __init__(self, orderId=None, isAuthorized=None,):
14756 
    self.orderId = orderId
14757 
    self.isAuthorized = isAuthorized
14758 
 
14759 
  def read(self, iprot):
14760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14762 
      return
14763 
    iprot.readStructBegin()
14764 
    while True:
14765 
      (fname, ftype, fid) = iprot.readFieldBegin()
14766 
      if ftype == TType.STOP:
14767 
        break
14768 
      if fid == 1:
14769 
        if ftype == TType.I64:
14770 
          self.orderId = iprot.readI64();
14771 
        else:
14772 
          iprot.skip(ftype)
14773 
      elif fid == 2:
14774 
        if ftype == TType.BOOL:
14775 
          self.isAuthorized = iprot.readBool();
14776 
        else:
14777 
          iprot.skip(ftype)
14778 
      else:
14779 
        iprot.skip(ftype)
14780 
      iprot.readFieldEnd()
14781 
    iprot.readStructEnd()
14782 
 
14783 
  def write(self, oprot):
14784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14786 
      return
14787 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14788 
    if self.orderId is not None:
14789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14790 
      oprot.writeI64(self.orderId)
14791 
      oprot.writeFieldEnd()
14792 
    if self.isAuthorized is not None:
14793 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14794 
      oprot.writeBool(self.isAuthorized)
14795 
      oprot.writeFieldEnd()
14796 
    oprot.writeFieldStop()
14797 
    oprot.writeStructEnd()
14798 
 
14799 
  def validate(self):
14800 
    return
14801 
 
14802 
 
14803 
  def __repr__(self):
14804 
    L = ['%s=%r' % (key, value)
14805 
      for key, value in self.__dict__.iteritems()]
14806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14807 
 
14808 
  def __eq__(self, other):
14809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14810 
 
14811 
  def __ne__(self, other):
14812 
    return not (self == other)
14813 
 
14814 
class markOrderReturnRequestAuthorized_result:
14815 
  """
14816 
  Attributes:
14817 
   - success
14818 
   - ex
14819 
  """
14820 
 
14821 
  thrift_spec = (
14822 
    (0, TType.BOOL, 'success', None, None, ), # 0
14823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14824 
  )
14825 
 
14826 
  def __init__(self, success=None, ex=None,):
14827 
    self.success = success
14828 
    self.ex = ex
14829 
 
14830 
  def read(self, iprot):
14831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14833 
      return
14834 
    iprot.readStructBegin()
14835 
    while True:
14836 
      (fname, ftype, fid) = iprot.readFieldBegin()
14837 
      if ftype == TType.STOP:
14838 
        break
14839 
      if fid == 0:
14840 
        if ftype == TType.BOOL:
14841 
          self.success = iprot.readBool();
14842 
        else:
14843 
          iprot.skip(ftype)
14844 
      elif fid == 1:
14845 
        if ftype == TType.STRUCT:
14846 
          self.ex = TransactionServiceException()
14847 
          self.ex.read(iprot)
14848 
        else:
14849 
          iprot.skip(ftype)
14850 
      else:
14851 
        iprot.skip(ftype)
14852 
      iprot.readFieldEnd()
14853 
    iprot.readStructEnd()
14854 
 
14855 
  def write(self, oprot):
14856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14858 
      return
14859 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14860 
    if self.success is not None:
14861 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14862 
      oprot.writeBool(self.success)
14863 
      oprot.writeFieldEnd()
14864 
    if self.ex is not None:
14865 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14866 
      self.ex.write(oprot)
14867 
      oprot.writeFieldEnd()
14868 
    oprot.writeFieldStop()
14869 
    oprot.writeStructEnd()
14870 
 
14871 
  def validate(self):
14872 
    return
14873 
 
14874 
 
14875 
  def __repr__(self):
14876 
    L = ['%s=%r' % (key, value)
14877 
      for key, value in self.__dict__.iteritems()]
14878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14879 
 
14880 
  def __eq__(self, other):
14881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14882 
 
14883 
  def __ne__(self, other):
14884 
    return not (self == other)
14885 
 
2536 chandransh 14886 
class requestPickupNumber_args:
14887 
  """
14888 
  Attributes:
14889 
   - orderId
4579 rajveer 14890 
   - providerId
2536 chandransh 14891 
  """
14892 
 
14893 
  thrift_spec = (
14894 
    None, # 0
14895 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14896 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14897 
  )
14898 
 
4579 rajveer 14899 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14900 
    self.orderId = orderId
4579 rajveer 14901 
    self.providerId = providerId
2536 chandransh 14902 
 
14903 
  def read(self, iprot):
14904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14906 
      return
14907 
    iprot.readStructBegin()
14908 
    while True:
14909 
      (fname, ftype, fid) = iprot.readFieldBegin()
14910 
      if ftype == TType.STOP:
14911 
        break
14912 
      if fid == 1:
14913 
        if ftype == TType.I64:
14914 
          self.orderId = iprot.readI64();
14915 
        else:
14916 
          iprot.skip(ftype)
4579 rajveer 14917 
      elif fid == 2:
14918 
        if ftype == TType.I64:
14919 
          self.providerId = iprot.readI64();
14920 
        else:
14921 
          iprot.skip(ftype)
2536 chandransh 14922 
      else:
14923 
        iprot.skip(ftype)
14924 
      iprot.readFieldEnd()
14925 
    iprot.readStructEnd()
14926 
 
14927 
  def write(self, oprot):
14928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14930 
      return
14931 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14932 
    if self.orderId is not None:
2536 chandransh 14933 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14934 
      oprot.writeI64(self.orderId)
14935 
      oprot.writeFieldEnd()
4579 rajveer 14936 
    if self.providerId is not None:
14937 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14938 
      oprot.writeI64(self.providerId)
14939 
      oprot.writeFieldEnd()
2536 chandransh 14940 
    oprot.writeFieldStop()
14941 
    oprot.writeStructEnd()
14942 
 
3431 rajveer 14943 
  def validate(self):
14944 
    return
14945 
 
14946 
 
2536 chandransh 14947 
  def __repr__(self):
14948 
    L = ['%s=%r' % (key, value)
14949 
      for key, value in self.__dict__.iteritems()]
14950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14951 
 
14952 
  def __eq__(self, other):
14953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14954 
 
14955 
  def __ne__(self, other):
14956 
    return not (self == other)
14957 
 
14958 
class requestPickupNumber_result:
14959 
  """
14960 
  Attributes:
14961 
   - success
14962 
   - ex
14963 
  """
14964 
 
14965 
  thrift_spec = (
14966 
    (0, TType.BOOL, 'success', None, None, ), # 0
14967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14968 
  )
14969 
 
14970 
  def __init__(self, success=None, ex=None,):
14971 
    self.success = success
14972 
    self.ex = ex
14973 
 
14974 
  def read(self, iprot):
14975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14977 
      return
14978 
    iprot.readStructBegin()
14979 
    while True:
14980 
      (fname, ftype, fid) = iprot.readFieldBegin()
14981 
      if ftype == TType.STOP:
14982 
        break
14983 
      if fid == 0:
14984 
        if ftype == TType.BOOL:
14985 
          self.success = iprot.readBool();
14986 
        else:
14987 
          iprot.skip(ftype)
14988 
      elif fid == 1:
14989 
        if ftype == TType.STRUCT:
14990 
          self.ex = TransactionServiceException()
14991 
          self.ex.read(iprot)
14992 
        else:
14993 
          iprot.skip(ftype)
14994 
      else:
14995 
        iprot.skip(ftype)
14996 
      iprot.readFieldEnd()
14997 
    iprot.readStructEnd()
14998 
 
14999 
  def write(self, oprot):
15000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15002 
      return
15003 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15004 
    if self.success is not None:
2536 chandransh 15005 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15006 
      oprot.writeBool(self.success)
15007 
      oprot.writeFieldEnd()
3431 rajveer 15008 
    if self.ex is not None:
2536 chandransh 15009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15010 
      self.ex.write(oprot)
15011 
      oprot.writeFieldEnd()
15012 
    oprot.writeFieldStop()
15013 
    oprot.writeStructEnd()
15014 
 
3431 rajveer 15015 
  def validate(self):
15016 
    return
15017 
 
15018 
 
2536 chandransh 15019 
  def __repr__(self):
15020 
    L = ['%s=%r' % (key, value)
15021 
      for key, value in self.__dict__.iteritems()]
15022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15023 
 
15024 
  def __eq__(self, other):
15025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15026 
 
15027 
  def __ne__(self, other):
15028 
    return not (self == other)
15029 
 
15030 
class authorizePickup_args:
15031 
  """
15032 
  Attributes:
15033 
   - orderId
15034 
   - pickupNumber
4602 rajveer 15035 
   - providerId
2536 chandransh 15036 
  """
15037 
 
15038 
  thrift_spec = (
15039 
    None, # 0
15040 
    (1, TType.I64, 'orderId', None, None, ), # 1
15041 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15042 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15043 
  )
15044 
 
4602 rajveer 15045 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15046 
    self.orderId = orderId
15047 
    self.pickupNumber = pickupNumber
4602 rajveer 15048 
    self.providerId = providerId
2536 chandransh 15049 
 
15050 
  def read(self, iprot):
15051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15053 
      return
15054 
    iprot.readStructBegin()
15055 
    while True:
15056 
      (fname, ftype, fid) = iprot.readFieldBegin()
15057 
      if ftype == TType.STOP:
15058 
        break
15059 
      if fid == 1:
15060 
        if ftype == TType.I64:
15061 
          self.orderId = iprot.readI64();
15062 
        else:
15063 
          iprot.skip(ftype)
15064 
      elif fid == 2:
15065 
        if ftype == TType.STRING:
15066 
          self.pickupNumber = iprot.readString();
15067 
        else:
15068 
          iprot.skip(ftype)
4602 rajveer 15069 
      elif fid == 3:
15070 
        if ftype == TType.I64:
15071 
          self.providerId = iprot.readI64();
15072 
        else:
15073 
          iprot.skip(ftype)
2536 chandransh 15074 
      else:
15075 
        iprot.skip(ftype)
15076 
      iprot.readFieldEnd()
15077 
    iprot.readStructEnd()
15078 
 
15079 
  def write(self, oprot):
15080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15082 
      return
15083 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15084 
    if self.orderId is not None:
2536 chandransh 15085 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15086 
      oprot.writeI64(self.orderId)
15087 
      oprot.writeFieldEnd()
3431 rajveer 15088 
    if self.pickupNumber is not None:
2536 chandransh 15089 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15090 
      oprot.writeString(self.pickupNumber)
15091 
      oprot.writeFieldEnd()
4602 rajveer 15092 
    if self.providerId is not None:
15093 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15094 
      oprot.writeI64(self.providerId)
15095 
      oprot.writeFieldEnd()
2536 chandransh 15096 
    oprot.writeFieldStop()
15097 
    oprot.writeStructEnd()
15098 
 
3431 rajveer 15099 
  def validate(self):
15100 
    return
15101 
 
15102 
 
2536 chandransh 15103 
  def __repr__(self):
15104 
    L = ['%s=%r' % (key, value)
15105 
      for key, value in self.__dict__.iteritems()]
15106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15107 
 
15108 
  def __eq__(self, other):
15109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15110 
 
15111 
  def __ne__(self, other):
15112 
    return not (self == other)
15113 
 
15114 
class authorizePickup_result:
15115 
  """
15116 
  Attributes:
15117 
   - success
15118 
   - ex
15119 
  """
15120 
 
15121 
  thrift_spec = (
15122 
    (0, TType.BOOL, 'success', None, None, ), # 0
15123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15124 
  )
15125 
 
15126 
  def __init__(self, success=None, ex=None,):
15127 
    self.success = success
15128 
    self.ex = ex
15129 
 
15130 
  def read(self, iprot):
15131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15133 
      return
15134 
    iprot.readStructBegin()
15135 
    while True:
15136 
      (fname, ftype, fid) = iprot.readFieldBegin()
15137 
      if ftype == TType.STOP:
15138 
        break
15139 
      if fid == 0:
15140 
        if ftype == TType.BOOL:
15141 
          self.success = iprot.readBool();
15142 
        else:
15143 
          iprot.skip(ftype)
15144 
      elif fid == 1:
15145 
        if ftype == TType.STRUCT:
15146 
          self.ex = TransactionServiceException()
15147 
          self.ex.read(iprot)
15148 
        else:
15149 
          iprot.skip(ftype)
15150 
      else:
15151 
        iprot.skip(ftype)
15152 
      iprot.readFieldEnd()
15153 
    iprot.readStructEnd()
15154 
 
15155 
  def write(self, oprot):
15156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15158 
      return
15159 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 15160 
    if self.success is not None:
2536 chandransh 15161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15162 
      oprot.writeBool(self.success)
15163 
      oprot.writeFieldEnd()
3431 rajveer 15164 
    if self.ex is not None:
2536 chandransh 15165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15166 
      self.ex.write(oprot)
15167 
      oprot.writeFieldEnd()
15168 
    oprot.writeFieldStop()
15169 
    oprot.writeStructEnd()
15170 
 
3431 rajveer 15171 
  def validate(self):
15172 
    return
15173 
 
15174 
 
2536 chandransh 15175 
  def __repr__(self):
15176 
    L = ['%s=%r' % (key, value)
15177 
      for key, value in self.__dict__.iteritems()]
15178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15179 
 
15180 
  def __eq__(self, other):
15181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15182 
 
15183 
  def __ne__(self, other):
15184 
    return not (self == other)
15185 
 
2764 chandransh 15186 
class markDoasAsPickedUp_args:
15187 
  """
15188 
  Attributes:
15189 
   - providerId
15190 
   - pickupDetails
15191 
  """
15192 
 
15193 
  thrift_spec = (
15194 
    None, # 0
15195 
    (1, TType.I64, 'providerId', None, None, ), # 1
15196 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15197 
  )
15198 
 
15199 
  def __init__(self, providerId=None, pickupDetails=None,):
15200 
    self.providerId = providerId
15201 
    self.pickupDetails = pickupDetails
15202 
 
15203 
  def read(self, iprot):
15204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15206 
      return
15207 
    iprot.readStructBegin()
15208 
    while True:
15209 
      (fname, ftype, fid) = iprot.readFieldBegin()
15210 
      if ftype == TType.STOP:
15211 
        break
15212 
      if fid == 1:
15213 
        if ftype == TType.I64:
15214 
          self.providerId = iprot.readI64();
15215 
        else:
15216 
          iprot.skip(ftype)
15217 
      elif fid == 2:
15218 
        if ftype == TType.MAP:
15219 
          self.pickupDetails = {}
5411 rajveer 15220 
          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
15221 
          for _i354 in xrange(_size350):
15222 
            _key355 = iprot.readString();
15223 
            _val356 = iprot.readString();
15224 
            self.pickupDetails[_key355] = _val356
2764 chandransh 15225 
          iprot.readMapEnd()
15226 
        else:
15227 
          iprot.skip(ftype)
15228 
      else:
15229 
        iprot.skip(ftype)
15230 
      iprot.readFieldEnd()
15231 
    iprot.readStructEnd()
15232 
 
15233 
  def write(self, oprot):
15234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15236 
      return
15237 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 15238 
    if self.providerId is not None:
2764 chandransh 15239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15240 
      oprot.writeI64(self.providerId)
15241 
      oprot.writeFieldEnd()
3431 rajveer 15242 
    if self.pickupDetails is not None:
2764 chandransh 15243 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15244 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15245 
      for kiter357,viter358 in self.pickupDetails.items():
15246 
        oprot.writeString(kiter357)
15247 
        oprot.writeString(viter358)
2764 chandransh 15248 
      oprot.writeMapEnd()
15249 
      oprot.writeFieldEnd()
15250 
    oprot.writeFieldStop()
15251 
    oprot.writeStructEnd()
15252 
 
3431 rajveer 15253 
  def validate(self):
15254 
    return
15255 
 
15256 
 
2764 chandransh 15257 
  def __repr__(self):
15258 
    L = ['%s=%r' % (key, value)
15259 
      for key, value in self.__dict__.iteritems()]
15260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15261 
 
15262 
  def __eq__(self, other):
15263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15264 
 
15265 
  def __ne__(self, other):
15266 
    return not (self == other)
15267 
 
15268 
class markDoasAsPickedUp_result:
4910 phani.kuma 15269 
 
15270 
  thrift_spec = (
15271 
  )
15272 
 
15273 
  def read(self, iprot):
15274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15276 
      return
15277 
    iprot.readStructBegin()
15278 
    while True:
15279 
      (fname, ftype, fid) = iprot.readFieldBegin()
15280 
      if ftype == TType.STOP:
15281 
        break
15282 
      else:
15283 
        iprot.skip(ftype)
15284 
      iprot.readFieldEnd()
15285 
    iprot.readStructEnd()
15286 
 
15287 
  def write(self, oprot):
15288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15290 
      return
15291 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
15292 
    oprot.writeFieldStop()
15293 
    oprot.writeStructEnd()
15294 
 
15295 
  def validate(self):
15296 
    return
15297 
 
15298 
 
15299 
  def __repr__(self):
15300 
    L = ['%s=%r' % (key, value)
15301 
      for key, value in self.__dict__.iteritems()]
15302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15303 
 
15304 
  def __eq__(self, other):
15305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15306 
 
15307 
  def __ne__(self, other):
15308 
    return not (self == other)
15309 
 
15310 
class getDoasNotPickedUp_args:
2764 chandransh 15311 
  """
15312 
  Attributes:
4910 phani.kuma 15313 
   - providerId
15314 
  """
15315 
 
15316 
  thrift_spec = (
15317 
    None, # 0
15318 
    (1, TType.I64, 'providerId', None, None, ), # 1
15319 
  )
15320 
 
15321 
  def __init__(self, providerId=None,):
15322 
    self.providerId = providerId
15323 
 
15324 
  def read(self, iprot):
15325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15327 
      return
15328 
    iprot.readStructBegin()
15329 
    while True:
15330 
      (fname, ftype, fid) = iprot.readFieldBegin()
15331 
      if ftype == TType.STOP:
15332 
        break
15333 
      if fid == 1:
15334 
        if ftype == TType.I64:
15335 
          self.providerId = iprot.readI64();
15336 
        else:
15337 
          iprot.skip(ftype)
15338 
      else:
15339 
        iprot.skip(ftype)
15340 
      iprot.readFieldEnd()
15341 
    iprot.readStructEnd()
15342 
 
15343 
  def write(self, oprot):
15344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15346 
      return
15347 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15348 
    if self.providerId is not None:
15349 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15350 
      oprot.writeI64(self.providerId)
15351 
      oprot.writeFieldEnd()
15352 
    oprot.writeFieldStop()
15353 
    oprot.writeStructEnd()
15354 
 
15355 
  def validate(self):
15356 
    return
15357 
 
15358 
 
15359 
  def __repr__(self):
15360 
    L = ['%s=%r' % (key, value)
15361 
      for key, value in self.__dict__.iteritems()]
15362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15363 
 
15364 
  def __eq__(self, other):
15365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15366 
 
15367 
  def __ne__(self, other):
15368 
    return not (self == other)
15369 
 
15370 
class getDoasNotPickedUp_result:
15371 
  """
15372 
  Attributes:
2764 chandransh 15373 
   - success
15374 
  """
15375 
 
15376 
  thrift_spec = (
15377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15378 
  )
15379 
 
15380 
  def __init__(self, success=None,):
15381 
    self.success = success
15382 
 
15383 
  def read(self, iprot):
15384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15386 
      return
15387 
    iprot.readStructBegin()
15388 
    while True:
15389 
      (fname, ftype, fid) = iprot.readFieldBegin()
15390 
      if ftype == TType.STOP:
15391 
        break
15392 
      if fid == 0:
15393 
        if ftype == TType.LIST:
15394 
          self.success = []
5411 rajveer 15395 
          (_etype362, _size359) = iprot.readListBegin()
15396 
          for _i363 in xrange(_size359):
15397 
            _elem364 = Order()
15398 
            _elem364.read(iprot)
15399 
            self.success.append(_elem364)
2764 chandransh 15400 
          iprot.readListEnd()
15401 
        else:
15402 
          iprot.skip(ftype)
15403 
      else:
15404 
        iprot.skip(ftype)
15405 
      iprot.readFieldEnd()
15406 
    iprot.readStructEnd()
15407 
 
15408 
  def write(self, oprot):
15409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15411 
      return
4910 phani.kuma 15412 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15413 
    if self.success is not None:
2764 chandransh 15414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15416 
      for iter365 in self.success:
15417 
        iter365.write(oprot)
2764 chandransh 15418 
      oprot.writeListEnd()
15419 
      oprot.writeFieldEnd()
15420 
    oprot.writeFieldStop()
15421 
    oprot.writeStructEnd()
15422 
 
3431 rajveer 15423 
  def validate(self):
15424 
    return
15425 
 
15426 
 
2764 chandransh 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 
 
4741 phani.kuma 15438 
class markReturnOrdersAsPickedUp_args:
15439 
  """
15440 
  Attributes:
15441 
   - providerId
15442 
   - pickupDetails
15443 
  """
15444 
 
15445 
  thrift_spec = (
15446 
    None, # 0
15447 
    (1, TType.I64, 'providerId', None, None, ), # 1
15448 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15449 
  )
15450 
 
15451 
  def __init__(self, providerId=None, pickupDetails=None,):
15452 
    self.providerId = providerId
15453 
    self.pickupDetails = pickupDetails
15454 
 
15455 
  def read(self, iprot):
15456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15458 
      return
15459 
    iprot.readStructBegin()
15460 
    while True:
15461 
      (fname, ftype, fid) = iprot.readFieldBegin()
15462 
      if ftype == TType.STOP:
15463 
        break
15464 
      if fid == 1:
15465 
        if ftype == TType.I64:
15466 
          self.providerId = iprot.readI64();
15467 
        else:
15468 
          iprot.skip(ftype)
15469 
      elif fid == 2:
15470 
        if ftype == TType.MAP:
15471 
          self.pickupDetails = {}
5411 rajveer 15472 
          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
15473 
          for _i370 in xrange(_size366):
15474 
            _key371 = iprot.readString();
15475 
            _val372 = iprot.readString();
15476 
            self.pickupDetails[_key371] = _val372
4741 phani.kuma 15477 
          iprot.readMapEnd()
15478 
        else:
15479 
          iprot.skip(ftype)
15480 
      else:
15481 
        iprot.skip(ftype)
15482 
      iprot.readFieldEnd()
15483 
    iprot.readStructEnd()
15484 
 
15485 
  def write(self, oprot):
15486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15488 
      return
15489 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15490 
    if self.providerId is not None:
15491 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15492 
      oprot.writeI64(self.providerId)
15493 
      oprot.writeFieldEnd()
15494 
    if self.pickupDetails is not None:
15495 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15496 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5411 rajveer 15497 
      for kiter373,viter374 in self.pickupDetails.items():
15498 
        oprot.writeString(kiter373)
15499 
        oprot.writeString(viter374)
4741 phani.kuma 15500 
      oprot.writeMapEnd()
15501 
      oprot.writeFieldEnd()
15502 
    oprot.writeFieldStop()
15503 
    oprot.writeStructEnd()
15504 
 
15505 
  def validate(self):
15506 
    return
15507 
 
15508 
 
15509 
  def __repr__(self):
15510 
    L = ['%s=%r' % (key, value)
15511 
      for key, value in self.__dict__.iteritems()]
15512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15513 
 
15514 
  def __eq__(self, other):
15515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15516 
 
15517 
  def __ne__(self, other):
15518 
    return not (self == other)
15519 
 
15520 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15521 
 
15522 
  thrift_spec = (
15523 
  )
15524 
 
15525 
  def read(self, iprot):
15526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15528 
      return
15529 
    iprot.readStructBegin()
15530 
    while True:
15531 
      (fname, ftype, fid) = iprot.readFieldBegin()
15532 
      if ftype == TType.STOP:
15533 
        break
15534 
      else:
15535 
        iprot.skip(ftype)
15536 
      iprot.readFieldEnd()
15537 
    iprot.readStructEnd()
15538 
 
15539 
  def write(self, oprot):
15540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15542 
      return
15543 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15544 
    oprot.writeFieldStop()
15545 
    oprot.writeStructEnd()
15546 
 
15547 
  def validate(self):
15548 
    return
15549 
 
15550 
 
15551 
  def __repr__(self):
15552 
    L = ['%s=%r' % (key, value)
15553 
      for key, value in self.__dict__.iteritems()]
15554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15555 
 
15556 
  def __eq__(self, other):
15557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15558 
 
15559 
  def __ne__(self, other):
15560 
    return not (self == other)
15561 
 
15562 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15563 
  """
15564 
  Attributes:
4910 phani.kuma 15565 
   - providerId
15566 
  """
15567 
 
15568 
  thrift_spec = (
15569 
    None, # 0
15570 
    (1, TType.I64, 'providerId', None, None, ), # 1
15571 
  )
15572 
 
15573 
  def __init__(self, providerId=None,):
15574 
    self.providerId = providerId
15575 
 
15576 
  def read(self, iprot):
15577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15579 
      return
15580 
    iprot.readStructBegin()
15581 
    while True:
15582 
      (fname, ftype, fid) = iprot.readFieldBegin()
15583 
      if ftype == TType.STOP:
15584 
        break
15585 
      if fid == 1:
15586 
        if ftype == TType.I64:
15587 
          self.providerId = iprot.readI64();
15588 
        else:
15589 
          iprot.skip(ftype)
15590 
      else:
15591 
        iprot.skip(ftype)
15592 
      iprot.readFieldEnd()
15593 
    iprot.readStructEnd()
15594 
 
15595 
  def write(self, oprot):
15596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15598 
      return
15599 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15600 
    if self.providerId is not None:
15601 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15602 
      oprot.writeI64(self.providerId)
15603 
      oprot.writeFieldEnd()
15604 
    oprot.writeFieldStop()
15605 
    oprot.writeStructEnd()
15606 
 
15607 
  def validate(self):
15608 
    return
15609 
 
15610 
 
15611 
  def __repr__(self):
15612 
    L = ['%s=%r' % (key, value)
15613 
      for key, value in self.__dict__.iteritems()]
15614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15615 
 
15616 
  def __eq__(self, other):
15617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15618 
 
15619 
  def __ne__(self, other):
15620 
    return not (self == other)
15621 
 
15622 
class getReturnOrdersNotPickedUp_result:
15623 
  """
15624 
  Attributes:
4741 phani.kuma 15625 
   - success
15626 
  """
15627 
 
15628 
  thrift_spec = (
15629 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15630 
  )
15631 
 
15632 
  def __init__(self, success=None,):
15633 
    self.success = success
15634 
 
15635 
  def read(self, iprot):
15636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15638 
      return
15639 
    iprot.readStructBegin()
15640 
    while True:
15641 
      (fname, ftype, fid) = iprot.readFieldBegin()
15642 
      if ftype == TType.STOP:
15643 
        break
15644 
      if fid == 0:
15645 
        if ftype == TType.LIST:
15646 
          self.success = []
5411 rajveer 15647 
          (_etype378, _size375) = iprot.readListBegin()
15648 
          for _i379 in xrange(_size375):
15649 
            _elem380 = Order()
15650 
            _elem380.read(iprot)
15651 
            self.success.append(_elem380)
4741 phani.kuma 15652 
          iprot.readListEnd()
15653 
        else:
15654 
          iprot.skip(ftype)
15655 
      else:
15656 
        iprot.skip(ftype)
15657 
      iprot.readFieldEnd()
15658 
    iprot.readStructEnd()
15659 
 
15660 
  def write(self, oprot):
15661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15663 
      return
4910 phani.kuma 15664 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15665 
    if self.success is not None:
15666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15667 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 15668 
      for iter381 in self.success:
15669 
        iter381.write(oprot)
4741 phani.kuma 15670 
      oprot.writeListEnd()
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 
 
2616 chandransh 15690 
class receiveReturn_args:
2591 chandransh 15691 
  """
15692 
  Attributes:
15693 
   - orderId
4479 rajveer 15694 
   - receiveCondition
2591 chandransh 15695 
  """
2536 chandransh 15696 
 
2591 chandransh 15697 
  thrift_spec = (
15698 
    None, # 0
15699 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15700 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15701 
  )
15702 
 
4479 rajveer 15703 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15704 
    self.orderId = orderId
4479 rajveer 15705 
    self.receiveCondition = receiveCondition
2591 chandransh 15706 
 
15707 
  def read(self, iprot):
15708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15710 
      return
15711 
    iprot.readStructBegin()
15712 
    while True:
15713 
      (fname, ftype, fid) = iprot.readFieldBegin()
15714 
      if ftype == TType.STOP:
15715 
        break
15716 
      if fid == 1:
15717 
        if ftype == TType.I64:
15718 
          self.orderId = iprot.readI64();
15719 
        else:
15720 
          iprot.skip(ftype)
4479 rajveer 15721 
      elif fid == 2:
15722 
        if ftype == TType.I64:
15723 
          self.receiveCondition = iprot.readI64();
15724 
        else:
15725 
          iprot.skip(ftype)
2591 chandransh 15726 
      else:
15727 
        iprot.skip(ftype)
15728 
      iprot.readFieldEnd()
15729 
    iprot.readStructEnd()
15730 
 
15731 
  def write(self, oprot):
15732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15734 
      return
2616 chandransh 15735 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15736 
    if self.orderId is not None:
2591 chandransh 15737 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15738 
      oprot.writeI64(self.orderId)
15739 
      oprot.writeFieldEnd()
4479 rajveer 15740 
    if self.receiveCondition is not None:
15741 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15742 
      oprot.writeI64(self.receiveCondition)
15743 
      oprot.writeFieldEnd()
2591 chandransh 15744 
    oprot.writeFieldStop()
15745 
    oprot.writeStructEnd()
15746 
 
3431 rajveer 15747 
  def validate(self):
15748 
    return
15749 
 
15750 
 
2591 chandransh 15751 
  def __repr__(self):
15752 
    L = ['%s=%r' % (key, value)
15753 
      for key, value in self.__dict__.iteritems()]
15754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15755 
 
15756 
  def __eq__(self, other):
15757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15758 
 
15759 
  def __ne__(self, other):
15760 
    return not (self == other)
15761 
 
2616 chandransh 15762 
class receiveReturn_result:
2591 chandransh 15763 
  """
15764 
  Attributes:
15765 
   - success
15766 
   - ex
15767 
  """
15768 
 
15769 
  thrift_spec = (
15770 
    (0, TType.BOOL, 'success', None, None, ), # 0
15771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15772 
  )
15773 
 
15774 
  def __init__(self, success=None, ex=None,):
15775 
    self.success = success
15776 
    self.ex = ex
15777 
 
15778 
  def read(self, iprot):
15779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15781 
      return
15782 
    iprot.readStructBegin()
15783 
    while True:
15784 
      (fname, ftype, fid) = iprot.readFieldBegin()
15785 
      if ftype == TType.STOP:
15786 
        break
15787 
      if fid == 0:
15788 
        if ftype == TType.BOOL:
15789 
          self.success = iprot.readBool();
15790 
        else:
15791 
          iprot.skip(ftype)
15792 
      elif fid == 1:
15793 
        if ftype == TType.STRUCT:
15794 
          self.ex = TransactionServiceException()
15795 
          self.ex.read(iprot)
15796 
        else:
15797 
          iprot.skip(ftype)
15798 
      else:
15799 
        iprot.skip(ftype)
15800 
      iprot.readFieldEnd()
15801 
    iprot.readStructEnd()
15802 
 
15803 
  def write(self, oprot):
15804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15806 
      return
2616 chandransh 15807 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15808 
    if self.success is not None:
2591 chandransh 15809 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15810 
      oprot.writeBool(self.success)
15811 
      oprot.writeFieldEnd()
3431 rajveer 15812 
    if self.ex is not None:
2591 chandransh 15813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15814 
      self.ex.write(oprot)
15815 
      oprot.writeFieldEnd()
15816 
    oprot.writeFieldStop()
15817 
    oprot.writeStructEnd()
15818 
 
3431 rajveer 15819 
  def validate(self):
15820 
    return
15821 
 
15822 
 
2591 chandransh 15823 
  def __repr__(self):
15824 
    L = ['%s=%r' % (key, value)
15825 
      for key, value in self.__dict__.iteritems()]
15826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15827 
 
15828 
  def __eq__(self, other):
15829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15830 
 
15831 
  def __ne__(self, other):
15832 
    return not (self == other)
15833 
 
15834 
class validateDoa_args:
15835 
  """
15836 
  Attributes:
15837 
   - orderId
15838 
   - isValid
15839 
  """
15840 
 
15841 
  thrift_spec = (
15842 
    None, # 0
15843 
    (1, TType.I64, 'orderId', None, None, ), # 1
15844 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15845 
  )
15846 
 
15847 
  def __init__(self, orderId=None, isValid=None,):
15848 
    self.orderId = orderId
15849 
    self.isValid = isValid
15850 
 
15851 
  def read(self, iprot):
15852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15854 
      return
15855 
    iprot.readStructBegin()
15856 
    while True:
15857 
      (fname, ftype, fid) = iprot.readFieldBegin()
15858 
      if ftype == TType.STOP:
15859 
        break
15860 
      if fid == 1:
15861 
        if ftype == TType.I64:
15862 
          self.orderId = iprot.readI64();
15863 
        else:
15864 
          iprot.skip(ftype)
15865 
      elif fid == 2:
15866 
        if ftype == TType.BOOL:
15867 
          self.isValid = iprot.readBool();
15868 
        else:
15869 
          iprot.skip(ftype)
15870 
      else:
15871 
        iprot.skip(ftype)
15872 
      iprot.readFieldEnd()
15873 
    iprot.readStructEnd()
15874 
 
15875 
  def write(self, oprot):
15876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15878 
      return
15879 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15880 
    if self.orderId is not None:
2591 chandransh 15881 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15882 
      oprot.writeI64(self.orderId)
15883 
      oprot.writeFieldEnd()
3431 rajveer 15884 
    if self.isValid is not None:
2591 chandransh 15885 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15886 
      oprot.writeBool(self.isValid)
15887 
      oprot.writeFieldEnd()
15888 
    oprot.writeFieldStop()
15889 
    oprot.writeStructEnd()
15890 
 
3431 rajveer 15891 
  def validate(self):
15892 
    return
15893 
 
15894 
 
2591 chandransh 15895 
  def __repr__(self):
15896 
    L = ['%s=%r' % (key, value)
15897 
      for key, value in self.__dict__.iteritems()]
15898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15899 
 
15900 
  def __eq__(self, other):
15901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15902 
 
15903 
  def __ne__(self, other):
15904 
    return not (self == other)
15905 
 
15906 
class validateDoa_result:
15907 
  """
15908 
  Attributes:
15909 
   - success
15910 
   - ex
15911 
  """
15912 
 
15913 
  thrift_spec = (
15914 
    (0, TType.BOOL, 'success', None, None, ), # 0
15915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15916 
  )
15917 
 
15918 
  def __init__(self, success=None, ex=None,):
15919 
    self.success = success
15920 
    self.ex = ex
15921 
 
15922 
  def read(self, iprot):
15923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15925 
      return
15926 
    iprot.readStructBegin()
15927 
    while True:
15928 
      (fname, ftype, fid) = iprot.readFieldBegin()
15929 
      if ftype == TType.STOP:
15930 
        break
15931 
      if fid == 0:
15932 
        if ftype == TType.BOOL:
15933 
          self.success = iprot.readBool();
15934 
        else:
15935 
          iprot.skip(ftype)
15936 
      elif fid == 1:
15937 
        if ftype == TType.STRUCT:
15938 
          self.ex = TransactionServiceException()
15939 
          self.ex.read(iprot)
15940 
        else:
15941 
          iprot.skip(ftype)
15942 
      else:
15943 
        iprot.skip(ftype)
15944 
      iprot.readFieldEnd()
15945 
    iprot.readStructEnd()
15946 
 
15947 
  def write(self, oprot):
15948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15950 
      return
15951 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15952 
    if self.success is not None:
2591 chandransh 15953 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15954 
      oprot.writeBool(self.success)
15955 
      oprot.writeFieldEnd()
3431 rajveer 15956 
    if self.ex is not None:
2591 chandransh 15957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15958 
      self.ex.write(oprot)
15959 
      oprot.writeFieldEnd()
15960 
    oprot.writeFieldStop()
15961 
    oprot.writeStructEnd()
15962 
 
3431 rajveer 15963 
  def validate(self):
15964 
    return
15965 
 
15966 
 
2591 chandransh 15967 
  def __repr__(self):
15968 
    L = ['%s=%r' % (key, value)
15969 
      for key, value in self.__dict__.iteritems()]
15970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15971 
 
15972 
  def __eq__(self, other):
15973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15974 
 
15975 
  def __ne__(self, other):
15976 
    return not (self == other)
15977 
 
4495 rajveer 15978 
class validateReturnProduct_args:
15979 
  """
15980 
  Attributes:
15981 
   - orderId
15982 
   - isUsable
15983 
  """
15984 
 
15985 
  thrift_spec = (
15986 
    None, # 0
15987 
    (1, TType.I64, 'orderId', None, None, ), # 1
15988 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15989 
  )
15990 
 
15991 
  def __init__(self, orderId=None, isUsable=None,):
15992 
    self.orderId = orderId
15993 
    self.isUsable = isUsable
15994 
 
15995 
  def read(self, iprot):
15996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15998 
      return
15999 
    iprot.readStructBegin()
16000 
    while True:
16001 
      (fname, ftype, fid) = iprot.readFieldBegin()
16002 
      if ftype == TType.STOP:
16003 
        break
16004 
      if fid == 1:
16005 
        if ftype == TType.I64:
16006 
          self.orderId = iprot.readI64();
16007 
        else:
16008 
          iprot.skip(ftype)
16009 
      elif fid == 2:
16010 
        if ftype == TType.BOOL:
16011 
          self.isUsable = iprot.readBool();
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      else:
16015 
        iprot.skip(ftype)
16016 
      iprot.readFieldEnd()
16017 
    iprot.readStructEnd()
16018 
 
16019 
  def write(self, oprot):
16020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16022 
      return
16023 
    oprot.writeStructBegin('validateReturnProduct_args')
16024 
    if self.orderId is not None:
16025 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16026 
      oprot.writeI64(self.orderId)
16027 
      oprot.writeFieldEnd()
16028 
    if self.isUsable is not None:
16029 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16030 
      oprot.writeBool(self.isUsable)
16031 
      oprot.writeFieldEnd()
16032 
    oprot.writeFieldStop()
16033 
    oprot.writeStructEnd()
16034 
 
16035 
  def validate(self):
16036 
    return
16037 
 
16038 
 
16039 
  def __repr__(self):
16040 
    L = ['%s=%r' % (key, value)
16041 
      for key, value in self.__dict__.iteritems()]
16042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16043 
 
16044 
  def __eq__(self, other):
16045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16046 
 
16047 
  def __ne__(self, other):
16048 
    return not (self == other)
16049 
 
16050 
class validateReturnProduct_result:
16051 
  """
16052 
  Attributes:
16053 
   - success
16054 
   - ex
16055 
  """
16056 
 
16057 
  thrift_spec = (
16058 
    (0, TType.BOOL, 'success', None, None, ), # 0
16059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16060 
  )
16061 
 
16062 
  def __init__(self, success=None, ex=None,):
16063 
    self.success = success
16064 
    self.ex = ex
16065 
 
16066 
  def read(self, iprot):
16067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16069 
      return
16070 
    iprot.readStructBegin()
16071 
    while True:
16072 
      (fname, ftype, fid) = iprot.readFieldBegin()
16073 
      if ftype == TType.STOP:
16074 
        break
16075 
      if fid == 0:
16076 
        if ftype == TType.BOOL:
16077 
          self.success = iprot.readBool();
16078 
        else:
16079 
          iprot.skip(ftype)
16080 
      elif fid == 1:
16081 
        if ftype == TType.STRUCT:
16082 
          self.ex = TransactionServiceException()
16083 
          self.ex.read(iprot)
16084 
        else:
16085 
          iprot.skip(ftype)
16086 
      else:
16087 
        iprot.skip(ftype)
16088 
      iprot.readFieldEnd()
16089 
    iprot.readStructEnd()
16090 
 
16091 
  def write(self, oprot):
16092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16094 
      return
16095 
    oprot.writeStructBegin('validateReturnProduct_result')
16096 
    if self.success is not None:
16097 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16098 
      oprot.writeBool(self.success)
16099 
      oprot.writeFieldEnd()
16100 
    if self.ex is not None:
16101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16102 
      self.ex.write(oprot)
16103 
      oprot.writeFieldEnd()
16104 
    oprot.writeFieldStop()
16105 
    oprot.writeStructEnd()
16106 
 
16107 
  def validate(self):
16108 
    return
16109 
 
16110 
 
16111 
  def __repr__(self):
16112 
    L = ['%s=%r' % (key, value)
16113 
      for key, value in self.__dict__.iteritems()]
16114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16115 
 
16116 
  def __eq__(self, other):
16117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16118 
 
16119 
  def __ne__(self, other):
16120 
    return not (self == other)
16121 
 
2616 chandransh 16122 
class reshipOrder_args:
16123 
  """
16124 
  Attributes:
16125 
   - orderId
16126 
  """
2591 chandransh 16127 
 
2616 chandransh 16128 
  thrift_spec = (
16129 
    None, # 0
16130 
    (1, TType.I64, 'orderId', None, None, ), # 1
16131 
  )
16132 
 
16133 
  def __init__(self, orderId=None,):
16134 
    self.orderId = orderId
16135 
 
16136 
  def read(self, iprot):
16137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16139 
      return
16140 
    iprot.readStructBegin()
16141 
    while True:
16142 
      (fname, ftype, fid) = iprot.readFieldBegin()
16143 
      if ftype == TType.STOP:
16144 
        break
16145 
      if fid == 1:
16146 
        if ftype == TType.I64:
16147 
          self.orderId = iprot.readI64();
16148 
        else:
16149 
          iprot.skip(ftype)
16150 
      else:
16151 
        iprot.skip(ftype)
16152 
      iprot.readFieldEnd()
16153 
    iprot.readStructEnd()
16154 
 
16155 
  def write(self, oprot):
16156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16158 
      return
16159 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 16160 
    if self.orderId is not None:
2616 chandransh 16161 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16162 
      oprot.writeI64(self.orderId)
16163 
      oprot.writeFieldEnd()
16164 
    oprot.writeFieldStop()
16165 
    oprot.writeStructEnd()
16166 
 
3431 rajveer 16167 
  def validate(self):
16168 
    return
16169 
 
16170 
 
2616 chandransh 16171 
  def __repr__(self):
16172 
    L = ['%s=%r' % (key, value)
16173 
      for key, value in self.__dict__.iteritems()]
16174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16175 
 
16176 
  def __eq__(self, other):
16177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16178 
 
16179 
  def __ne__(self, other):
16180 
    return not (self == other)
16181 
 
16182 
class reshipOrder_result:
16183 
  """
16184 
  Attributes:
16185 
   - success
16186 
   - ex
16187 
  """
16188 
 
16189 
  thrift_spec = (
16190 
    (0, TType.I64, 'success', None, None, ), # 0
16191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16192 
  )
16193 
 
16194 
  def __init__(self, success=None, ex=None,):
16195 
    self.success = success
16196 
    self.ex = ex
16197 
 
16198 
  def read(self, iprot):
16199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16201 
      return
16202 
    iprot.readStructBegin()
16203 
    while True:
16204 
      (fname, ftype, fid) = iprot.readFieldBegin()
16205 
      if ftype == TType.STOP:
16206 
        break
16207 
      if fid == 0:
16208 
        if ftype == TType.I64:
16209 
          self.success = iprot.readI64();
16210 
        else:
16211 
          iprot.skip(ftype)
16212 
      elif fid == 1:
16213 
        if ftype == TType.STRUCT:
16214 
          self.ex = TransactionServiceException()
16215 
          self.ex.read(iprot)
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_result')
3431 rajveer 16228 
    if self.success is not None:
2616 chandransh 16229 
      oprot.writeFieldBegin('success', TType.I64, 0)
16230 
      oprot.writeI64(self.success)
16231 
      oprot.writeFieldEnd()
3431 rajveer 16232 
    if self.ex is not None:
2616 chandransh 16233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16234 
      self.ex.write(oprot)
16235 
      oprot.writeFieldEnd()
16236 
    oprot.writeFieldStop()
16237 
    oprot.writeStructEnd()
16238 
 
3431 rajveer 16239 
  def validate(self):
16240 
    return
16241 
 
16242 
 
2616 chandransh 16243 
  def __repr__(self):
16244 
    L = ['%s=%r' % (key, value)
16245 
      for key, value in self.__dict__.iteritems()]
16246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16247 
 
16248 
  def __eq__(self, other):
16249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16250 
 
16251 
  def __ne__(self, other):
16252 
    return not (self == other)
16253 
 
16254 
class refundOrder_args:
16255 
  """
16256 
  Attributes:
16257 
   - orderId
3226 chandransh 16258 
   - refundedBy
16259 
   - reason
2616 chandransh 16260 
  """
16261 
 
16262 
  thrift_spec = (
16263 
    None, # 0
16264 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 16265 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16266 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 16267 
  )
16268 
 
3226 chandransh 16269 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 16270 
    self.orderId = orderId
3226 chandransh 16271 
    self.refundedBy = refundedBy
16272 
    self.reason = reason
2616 chandransh 16273 
 
16274 
  def read(self, iprot):
16275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16277 
      return
16278 
    iprot.readStructBegin()
16279 
    while True:
16280 
      (fname, ftype, fid) = iprot.readFieldBegin()
16281 
      if ftype == TType.STOP:
16282 
        break
16283 
      if fid == 1:
16284 
        if ftype == TType.I64:
16285 
          self.orderId = iprot.readI64();
16286 
        else:
16287 
          iprot.skip(ftype)
3226 chandransh 16288 
      elif fid == 2:
16289 
        if ftype == TType.STRING:
16290 
          self.refundedBy = iprot.readString();
16291 
        else:
16292 
          iprot.skip(ftype)
16293 
      elif fid == 3:
16294 
        if ftype == TType.STRING:
16295 
          self.reason = iprot.readString();
16296 
        else:
16297 
          iprot.skip(ftype)
2616 chandransh 16298 
      else:
16299 
        iprot.skip(ftype)
16300 
      iprot.readFieldEnd()
16301 
    iprot.readStructEnd()
16302 
 
16303 
  def write(self, oprot):
16304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16306 
      return
16307 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 16308 
    if self.orderId is not None:
2616 chandransh 16309 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16310 
      oprot.writeI64(self.orderId)
16311 
      oprot.writeFieldEnd()
3431 rajveer 16312 
    if self.refundedBy is not None:
3226 chandransh 16313 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16314 
      oprot.writeString(self.refundedBy)
16315 
      oprot.writeFieldEnd()
3431 rajveer 16316 
    if self.reason is not None:
3226 chandransh 16317 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16318 
      oprot.writeString(self.reason)
16319 
      oprot.writeFieldEnd()
2616 chandransh 16320 
    oprot.writeFieldStop()
16321 
    oprot.writeStructEnd()
16322 
 
3431 rajveer 16323 
  def validate(self):
16324 
    return
16325 
 
16326 
 
2616 chandransh 16327 
  def __repr__(self):
16328 
    L = ['%s=%r' % (key, value)
16329 
      for key, value in self.__dict__.iteritems()]
16330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16331 
 
16332 
  def __eq__(self, other):
16333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16334 
 
16335 
  def __ne__(self, other):
16336 
    return not (self == other)
16337 
 
16338 
class refundOrder_result:
16339 
  """
16340 
  Attributes:
16341 
   - success
16342 
   - ex
16343 
  """
16344 
 
16345 
  thrift_spec = (
16346 
    (0, TType.BOOL, 'success', None, None, ), # 0
16347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16348 
  )
16349 
 
16350 
  def __init__(self, success=None, ex=None,):
16351 
    self.success = success
16352 
    self.ex = ex
16353 
 
16354 
  def read(self, iprot):
16355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16357 
      return
16358 
    iprot.readStructBegin()
16359 
    while True:
16360 
      (fname, ftype, fid) = iprot.readFieldBegin()
16361 
      if ftype == TType.STOP:
16362 
        break
16363 
      if fid == 0:
16364 
        if ftype == TType.BOOL:
16365 
          self.success = iprot.readBool();
16366 
        else:
16367 
          iprot.skip(ftype)
16368 
      elif fid == 1:
16369 
        if ftype == TType.STRUCT:
16370 
          self.ex = TransactionServiceException()
16371 
          self.ex.read(iprot)
16372 
        else:
16373 
          iprot.skip(ftype)
16374 
      else:
16375 
        iprot.skip(ftype)
16376 
      iprot.readFieldEnd()
16377 
    iprot.readStructEnd()
16378 
 
16379 
  def write(self, oprot):
16380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16382 
      return
16383 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16384 
    if self.success is not None:
2616 chandransh 16385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16386 
      oprot.writeBool(self.success)
16387 
      oprot.writeFieldEnd()
3431 rajveer 16388 
    if self.ex is not None:
2616 chandransh 16389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16390 
      self.ex.write(oprot)
16391 
      oprot.writeFieldEnd()
16392 
    oprot.writeFieldStop()
16393 
    oprot.writeStructEnd()
16394 
 
3431 rajveer 16395 
  def validate(self):
16396 
    return
16397 
 
16398 
 
2616 chandransh 16399 
  def __repr__(self):
16400 
    L = ['%s=%r' % (key, value)
16401 
      for key, value in self.__dict__.iteritems()]
16402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16403 
 
16404 
  def __eq__(self, other):
16405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16406 
 
16407 
  def __ne__(self, other):
16408 
    return not (self == other)
16409 
 
2690 chandransh 16410 
class getReturnOrders_args:
16411 
  """
16412 
  Attributes:
16413 
   - warehouseId
16414 
   - fromDate
16415 
   - toDate
16416 
  """
2616 chandransh 16417 
 
2690 chandransh 16418 
  thrift_spec = (
16419 
    None, # 0
16420 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16421 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16422 
    (3, TType.I64, 'toDate', None, None, ), # 3
16423 
  )
16424 
 
16425 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16426 
    self.warehouseId = warehouseId
16427 
    self.fromDate = fromDate
16428 
    self.toDate = toDate
16429 
 
16430 
  def read(self, iprot):
16431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16433 
      return
16434 
    iprot.readStructBegin()
16435 
    while True:
16436 
      (fname, ftype, fid) = iprot.readFieldBegin()
16437 
      if ftype == TType.STOP:
16438 
        break
16439 
      if fid == 1:
16440 
        if ftype == TType.I64:
16441 
          self.warehouseId = iprot.readI64();
16442 
        else:
16443 
          iprot.skip(ftype)
16444 
      elif fid == 2:
16445 
        if ftype == TType.I64:
16446 
          self.fromDate = iprot.readI64();
16447 
        else:
16448 
          iprot.skip(ftype)
16449 
      elif fid == 3:
16450 
        if ftype == TType.I64:
16451 
          self.toDate = iprot.readI64();
16452 
        else:
16453 
          iprot.skip(ftype)
16454 
      else:
16455 
        iprot.skip(ftype)
16456 
      iprot.readFieldEnd()
16457 
    iprot.readStructEnd()
16458 
 
16459 
  def write(self, oprot):
16460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16462 
      return
16463 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16464 
    if self.warehouseId is not None:
2690 chandransh 16465 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16466 
      oprot.writeI64(self.warehouseId)
16467 
      oprot.writeFieldEnd()
3431 rajveer 16468 
    if self.fromDate is not None:
2690 chandransh 16469 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16470 
      oprot.writeI64(self.fromDate)
16471 
      oprot.writeFieldEnd()
3431 rajveer 16472 
    if self.toDate is not None:
2690 chandransh 16473 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16474 
      oprot.writeI64(self.toDate)
16475 
      oprot.writeFieldEnd()
16476 
    oprot.writeFieldStop()
16477 
    oprot.writeStructEnd()
16478 
 
3431 rajveer 16479 
  def validate(self):
16480 
    return
16481 
 
16482 
 
2690 chandransh 16483 
  def __repr__(self):
16484 
    L = ['%s=%r' % (key, value)
16485 
      for key, value in self.__dict__.iteritems()]
16486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16487 
 
16488 
  def __eq__(self, other):
16489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16490 
 
16491 
  def __ne__(self, other):
16492 
    return not (self == other)
16493 
 
16494 
class getReturnOrders_result:
16495 
  """
16496 
  Attributes:
16497 
   - success
16498 
  """
16499 
 
16500 
  thrift_spec = (
16501 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16502 
  )
16503 
 
16504 
  def __init__(self, success=None,):
16505 
    self.success = success
16506 
 
16507 
  def read(self, iprot):
16508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16510 
      return
16511 
    iprot.readStructBegin()
16512 
    while True:
16513 
      (fname, ftype, fid) = iprot.readFieldBegin()
16514 
      if ftype == TType.STOP:
16515 
        break
16516 
      if fid == 0:
16517 
        if ftype == TType.LIST:
16518 
          self.success = []
5411 rajveer 16519 
          (_etype385, _size382) = iprot.readListBegin()
16520 
          for _i386 in xrange(_size382):
16521 
            _elem387 = ReturnOrder()
16522 
            _elem387.read(iprot)
16523 
            self.success.append(_elem387)
2690 chandransh 16524 
          iprot.readListEnd()
16525 
        else:
16526 
          iprot.skip(ftype)
16527 
      else:
16528 
        iprot.skip(ftype)
16529 
      iprot.readFieldEnd()
16530 
    iprot.readStructEnd()
16531 
 
16532 
  def write(self, oprot):
16533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16535 
      return
16536 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16537 
    if self.success is not None:
2690 chandransh 16538 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16539 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 16540 
      for iter388 in self.success:
16541 
        iter388.write(oprot)
2690 chandransh 16542 
      oprot.writeListEnd()
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 
 
2700 chandransh 16562 
class getReturnOrder_args:
16563 
  """
16564 
  Attributes:
16565 
   - id
16566 
  """
16567 
 
16568 
  thrift_spec = (
16569 
    None, # 0
16570 
    (1, TType.I64, 'id', None, None, ), # 1
16571 
  )
16572 
 
16573 
  def __init__(self, id=None,):
16574 
    self.id = id
16575 
 
16576 
  def read(self, iprot):
16577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16579 
      return
16580 
    iprot.readStructBegin()
16581 
    while True:
16582 
      (fname, ftype, fid) = iprot.readFieldBegin()
16583 
      if ftype == TType.STOP:
16584 
        break
16585 
      if fid == 1:
16586 
        if ftype == TType.I64:
16587 
          self.id = iprot.readI64();
16588 
        else:
16589 
          iprot.skip(ftype)
16590 
      else:
16591 
        iprot.skip(ftype)
16592 
      iprot.readFieldEnd()
16593 
    iprot.readStructEnd()
16594 
 
16595 
  def write(self, oprot):
16596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16598 
      return
16599 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16600 
    if self.id is not None:
2700 chandransh 16601 
      oprot.writeFieldBegin('id', TType.I64, 1)
16602 
      oprot.writeI64(self.id)
16603 
      oprot.writeFieldEnd()
16604 
    oprot.writeFieldStop()
16605 
    oprot.writeStructEnd()
16606 
 
3431 rajveer 16607 
  def validate(self):
16608 
    return
16609 
 
16610 
 
2700 chandransh 16611 
  def __repr__(self):
16612 
    L = ['%s=%r' % (key, value)
16613 
      for key, value in self.__dict__.iteritems()]
16614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16615 
 
16616 
  def __eq__(self, other):
16617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16618 
 
16619 
  def __ne__(self, other):
16620 
    return not (self == other)
16621 
 
16622 
class getReturnOrder_result:
16623 
  """
16624 
  Attributes:
16625 
   - success
16626 
   - ex
16627 
  """
16628 
 
16629 
  thrift_spec = (
16630 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16632 
  )
16633 
 
16634 
  def __init__(self, success=None, ex=None,):
16635 
    self.success = success
16636 
    self.ex = ex
16637 
 
16638 
  def read(self, iprot):
16639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16641 
      return
16642 
    iprot.readStructBegin()
16643 
    while True:
16644 
      (fname, ftype, fid) = iprot.readFieldBegin()
16645 
      if ftype == TType.STOP:
16646 
        break
16647 
      if fid == 0:
16648 
        if ftype == TType.STRUCT:
16649 
          self.success = ReturnOrder()
16650 
          self.success.read(iprot)
16651 
        else:
16652 
          iprot.skip(ftype)
16653 
      elif fid == 1:
16654 
        if ftype == TType.STRUCT:
16655 
          self.ex = TransactionServiceException()
16656 
          self.ex.read(iprot)
16657 
        else:
16658 
          iprot.skip(ftype)
16659 
      else:
16660 
        iprot.skip(ftype)
16661 
      iprot.readFieldEnd()
16662 
    iprot.readStructEnd()
16663 
 
16664 
  def write(self, oprot):
16665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16667 
      return
16668 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16669 
    if self.success is not None:
2700 chandransh 16670 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16671 
      self.success.write(oprot)
16672 
      oprot.writeFieldEnd()
3431 rajveer 16673 
    if self.ex is not None:
2700 chandransh 16674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16675 
      self.ex.write(oprot)
16676 
      oprot.writeFieldEnd()
16677 
    oprot.writeFieldStop()
16678 
    oprot.writeStructEnd()
16679 
 
3431 rajveer 16680 
  def validate(self):
16681 
    return
16682 
 
16683 
 
2700 chandransh 16684 
  def __repr__(self):
16685 
    L = ['%s=%r' % (key, value)
16686 
      for key, value in self.__dict__.iteritems()]
16687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16688 
 
16689 
  def __eq__(self, other):
16690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16691 
 
16692 
  def __ne__(self, other):
16693 
    return not (self == other)
16694 
 
2690 chandransh 16695 
class processReturn_args:
16696 
  """
16697 
  Attributes:
16698 
   - returnOrderId
16699 
  """
16700 
 
16701 
  thrift_spec = (
16702 
    None, # 0
16703 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16704 
  )
16705 
 
16706 
  def __init__(self, returnOrderId=None,):
16707 
    self.returnOrderId = returnOrderId
16708 
 
16709 
  def read(self, iprot):
16710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16712 
      return
16713 
    iprot.readStructBegin()
16714 
    while True:
16715 
      (fname, ftype, fid) = iprot.readFieldBegin()
16716 
      if ftype == TType.STOP:
16717 
        break
16718 
      if fid == 1:
16719 
        if ftype == TType.I64:
16720 
          self.returnOrderId = iprot.readI64();
16721 
        else:
16722 
          iprot.skip(ftype)
16723 
      else:
16724 
        iprot.skip(ftype)
16725 
      iprot.readFieldEnd()
16726 
    iprot.readStructEnd()
16727 
 
16728 
  def write(self, oprot):
16729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16731 
      return
16732 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16733 
    if self.returnOrderId is not None:
2690 chandransh 16734 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16735 
      oprot.writeI64(self.returnOrderId)
16736 
      oprot.writeFieldEnd()
16737 
    oprot.writeFieldStop()
16738 
    oprot.writeStructEnd()
16739 
 
3431 rajveer 16740 
  def validate(self):
16741 
    return
16742 
 
16743 
 
2690 chandransh 16744 
  def __repr__(self):
16745 
    L = ['%s=%r' % (key, value)
16746 
      for key, value in self.__dict__.iteritems()]
16747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16748 
 
16749 
  def __eq__(self, other):
16750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16751 
 
16752 
  def __ne__(self, other):
16753 
    return not (self == other)
16754 
 
16755 
class processReturn_result:
16756 
  """
16757 
  Attributes:
16758 
   - ex
16759 
  """
16760 
 
16761 
  thrift_spec = (
16762 
    None, # 0
16763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16764 
  )
16765 
 
16766 
  def __init__(self, ex=None,):
16767 
    self.ex = ex
16768 
 
16769 
  def read(self, iprot):
16770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16772 
      return
16773 
    iprot.readStructBegin()
16774 
    while True:
16775 
      (fname, ftype, fid) = iprot.readFieldBegin()
16776 
      if ftype == TType.STOP:
16777 
        break
16778 
      if fid == 1:
16779 
        if ftype == TType.STRUCT:
16780 
          self.ex = TransactionServiceException()
16781 
          self.ex.read(iprot)
16782 
        else:
16783 
          iprot.skip(ftype)
16784 
      else:
16785 
        iprot.skip(ftype)
16786 
      iprot.readFieldEnd()
16787 
    iprot.readStructEnd()
16788 
 
16789 
  def write(self, oprot):
16790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16792 
      return
16793 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16794 
    if self.ex is not None:
2690 chandransh 16795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16796 
      self.ex.write(oprot)
16797 
      oprot.writeFieldEnd()
16798 
    oprot.writeFieldStop()
16799 
    oprot.writeStructEnd()
16800 
 
3431 rajveer 16801 
  def validate(self):
16802 
    return
16803 
 
16804 
 
2690 chandransh 16805 
  def __repr__(self):
16806 
    L = ['%s=%r' % (key, value)
16807 
      for key, value in self.__dict__.iteritems()]
16808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16809 
 
16810 
  def __eq__(self, other):
16811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16812 
 
16813 
  def __ne__(self, other):
16814 
    return not (self == other)
16815 
 
3451 chandransh 16816 
class updateWeight_args:
16817 
  """
16818 
  Attributes:
16819 
   - orderId
16820 
   - weight
16821 
  """
16822 
 
16823 
  thrift_spec = (
16824 
    None, # 0
16825 
    (1, TType.I64, 'orderId', None, None, ), # 1
16826 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16827 
  )
16828 
 
16829 
  def __init__(self, orderId=None, weight=None,):
16830 
    self.orderId = orderId
16831 
    self.weight = weight
16832 
 
16833 
  def read(self, iprot):
16834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16836 
      return
16837 
    iprot.readStructBegin()
16838 
    while True:
16839 
      (fname, ftype, fid) = iprot.readFieldBegin()
16840 
      if ftype == TType.STOP:
16841 
        break
16842 
      if fid == 1:
16843 
        if ftype == TType.I64:
16844 
          self.orderId = iprot.readI64();
16845 
        else:
16846 
          iprot.skip(ftype)
16847 
      elif fid == 2:
16848 
        if ftype == TType.DOUBLE:
16849 
          self.weight = iprot.readDouble();
16850 
        else:
16851 
          iprot.skip(ftype)
16852 
      else:
16853 
        iprot.skip(ftype)
16854 
      iprot.readFieldEnd()
16855 
    iprot.readStructEnd()
16856 
 
16857 
  def write(self, oprot):
16858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16860 
      return
16861 
    oprot.writeStructBegin('updateWeight_args')
16862 
    if self.orderId is not None:
16863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16864 
      oprot.writeI64(self.orderId)
16865 
      oprot.writeFieldEnd()
16866 
    if self.weight is not None:
16867 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16868 
      oprot.writeDouble(self.weight)
16869 
      oprot.writeFieldEnd()
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
16887 
 
16888 
class updateWeight_result:
16889 
  """
16890 
  Attributes:
16891 
   - success
16892 
   - ex
16893 
  """
16894 
 
16895 
  thrift_spec = (
16896 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16898 
  )
16899 
 
16900 
  def __init__(self, success=None, ex=None,):
16901 
    self.success = success
16902 
    self.ex = ex
16903 
 
16904 
  def read(self, iprot):
16905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16907 
      return
16908 
    iprot.readStructBegin()
16909 
    while True:
16910 
      (fname, ftype, fid) = iprot.readFieldBegin()
16911 
      if ftype == TType.STOP:
16912 
        break
16913 
      if fid == 0:
16914 
        if ftype == TType.STRUCT:
16915 
          self.success = Order()
16916 
          self.success.read(iprot)
16917 
        else:
16918 
          iprot.skip(ftype)
16919 
      elif fid == 1:
16920 
        if ftype == TType.STRUCT:
16921 
          self.ex = TransactionServiceException()
16922 
          self.ex.read(iprot)
16923 
        else:
16924 
          iprot.skip(ftype)
16925 
      else:
16926 
        iprot.skip(ftype)
16927 
      iprot.readFieldEnd()
16928 
    iprot.readStructEnd()
16929 
 
16930 
  def write(self, oprot):
16931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16933 
      return
16934 
    oprot.writeStructBegin('updateWeight_result')
16935 
    if self.success is not None:
16936 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16937 
      self.success.write(oprot)
16938 
      oprot.writeFieldEnd()
16939 
    if self.ex is not None:
16940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16941 
      self.ex.write(oprot)
16942 
      oprot.writeFieldEnd()
16943 
    oprot.writeFieldStop()
16944 
    oprot.writeStructEnd()
16945 
 
16946 
  def validate(self):
16947 
    return
16948 
 
16949 
 
16950 
  def __repr__(self):
16951 
    L = ['%s=%r' % (key, value)
16952 
      for key, value in self.__dict__.iteritems()]
16953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16954 
 
16955 
  def __eq__(self, other):
16956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16957 
 
16958 
  def __ne__(self, other):
16959 
    return not (self == other)
3469 chandransh 16960 
 
16961 
class changeItem_args:
16962 
  """
16963 
  Attributes:
16964 
   - orderId
16965 
   - itemId
16966 
  """
16967 
 
16968 
  thrift_spec = (
16969 
    None, # 0
16970 
    (1, TType.I64, 'orderId', None, None, ), # 1
16971 
    (2, TType.I64, 'itemId', None, None, ), # 2
16972 
  )
16973 
 
16974 
  def __init__(self, orderId=None, itemId=None,):
16975 
    self.orderId = orderId
16976 
    self.itemId = itemId
16977 
 
16978 
  def read(self, iprot):
16979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16981 
      return
16982 
    iprot.readStructBegin()
16983 
    while True:
16984 
      (fname, ftype, fid) = iprot.readFieldBegin()
16985 
      if ftype == TType.STOP:
16986 
        break
16987 
      if fid == 1:
16988 
        if ftype == TType.I64:
16989 
          self.orderId = iprot.readI64();
16990 
        else:
16991 
          iprot.skip(ftype)
16992 
      elif fid == 2:
16993 
        if ftype == TType.I64:
16994 
          self.itemId = iprot.readI64();
16995 
        else:
16996 
          iprot.skip(ftype)
16997 
      else:
16998 
        iprot.skip(ftype)
16999 
      iprot.readFieldEnd()
17000 
    iprot.readStructEnd()
17001 
 
17002 
  def write(self, oprot):
17003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17005 
      return
17006 
    oprot.writeStructBegin('changeItem_args')
17007 
    if self.orderId is not None:
17008 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17009 
      oprot.writeI64(self.orderId)
17010 
      oprot.writeFieldEnd()
17011 
    if self.itemId is not None:
17012 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17013 
      oprot.writeI64(self.itemId)
17014 
      oprot.writeFieldEnd()
17015 
    oprot.writeFieldStop()
17016 
    oprot.writeStructEnd()
17017 
 
17018 
  def validate(self):
17019 
    return
17020 
 
17021 
 
17022 
  def __repr__(self):
17023 
    L = ['%s=%r' % (key, value)
17024 
      for key, value in self.__dict__.iteritems()]
17025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17026 
 
17027 
  def __eq__(self, other):
17028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17029 
 
17030 
  def __ne__(self, other):
17031 
    return not (self == other)
17032 
 
17033 
class changeItem_result:
17034 
  """
17035 
  Attributes:
17036 
   - success
17037 
   - ex
17038 
  """
17039 
 
17040 
  thrift_spec = (
17041 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17043 
  )
17044 
 
17045 
  def __init__(self, success=None, ex=None,):
17046 
    self.success = success
17047 
    self.ex = ex
17048 
 
17049 
  def read(self, iprot):
17050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17052 
      return
17053 
    iprot.readStructBegin()
17054 
    while True:
17055 
      (fname, ftype, fid) = iprot.readFieldBegin()
17056 
      if ftype == TType.STOP:
17057 
        break
17058 
      if fid == 0:
17059 
        if ftype == TType.STRUCT:
17060 
          self.success = Order()
17061 
          self.success.read(iprot)
17062 
        else:
17063 
          iprot.skip(ftype)
17064 
      elif fid == 1:
17065 
        if ftype == TType.STRUCT:
17066 
          self.ex = TransactionServiceException()
17067 
          self.ex.read(iprot)
17068 
        else:
17069 
          iprot.skip(ftype)
17070 
      else:
17071 
        iprot.skip(ftype)
17072 
      iprot.readFieldEnd()
17073 
    iprot.readStructEnd()
17074 
 
17075 
  def write(self, oprot):
17076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17078 
      return
17079 
    oprot.writeStructBegin('changeItem_result')
17080 
    if self.success is not None:
17081 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17082 
      self.success.write(oprot)
17083 
      oprot.writeFieldEnd()
17084 
    if self.ex is not None:
17085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17086 
      self.ex.write(oprot)
17087 
      oprot.writeFieldEnd()
17088 
    oprot.writeFieldStop()
17089 
    oprot.writeStructEnd()
17090 
 
17091 
  def validate(self):
17092 
    return
17093 
 
17094 
 
17095 
  def __repr__(self):
17096 
    L = ['%s=%r' % (key, value)
17097 
      for key, value in self.__dict__.iteritems()]
17098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17099 
 
17100 
  def __eq__(self, other):
17101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17102 
 
17103 
  def __ne__(self, other):
17104 
    return not (self == other)
17105 
 
17106 
class shiftToWarehouse_args:
17107 
  """
17108 
  Attributes:
17109 
   - orderId
17110 
   - warehouseId
17111 
  """
17112 
 
17113 
  thrift_spec = (
17114 
    None, # 0
17115 
    (1, TType.I64, 'orderId', None, None, ), # 1
17116 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
17117 
  )
17118 
 
17119 
  def __init__(self, orderId=None, warehouseId=None,):
17120 
    self.orderId = orderId
17121 
    self.warehouseId = warehouseId
17122 
 
17123 
  def read(self, iprot):
17124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17126 
      return
17127 
    iprot.readStructBegin()
17128 
    while True:
17129 
      (fname, ftype, fid) = iprot.readFieldBegin()
17130 
      if ftype == TType.STOP:
17131 
        break
17132 
      if fid == 1:
17133 
        if ftype == TType.I64:
17134 
          self.orderId = iprot.readI64();
17135 
        else:
17136 
          iprot.skip(ftype)
17137 
      elif fid == 2:
17138 
        if ftype == TType.I64:
17139 
          self.warehouseId = iprot.readI64();
17140 
        else:
17141 
          iprot.skip(ftype)
17142 
      else:
17143 
        iprot.skip(ftype)
17144 
      iprot.readFieldEnd()
17145 
    iprot.readStructEnd()
17146 
 
17147 
  def write(self, oprot):
17148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17150 
      return
17151 
    oprot.writeStructBegin('shiftToWarehouse_args')
17152 
    if self.orderId is not None:
17153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17154 
      oprot.writeI64(self.orderId)
17155 
      oprot.writeFieldEnd()
17156 
    if self.warehouseId is not None:
17157 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17158 
      oprot.writeI64(self.warehouseId)
17159 
      oprot.writeFieldEnd()
17160 
    oprot.writeFieldStop()
17161 
    oprot.writeStructEnd()
17162 
 
17163 
  def validate(self):
17164 
    return
17165 
 
17166 
 
17167 
  def __repr__(self):
17168 
    L = ['%s=%r' % (key, value)
17169 
      for key, value in self.__dict__.iteritems()]
17170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17171 
 
17172 
  def __eq__(self, other):
17173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17174 
 
17175 
  def __ne__(self, other):
17176 
    return not (self == other)
17177 
 
17178 
class shiftToWarehouse_result:
17179 
  """
17180 
  Attributes:
17181 
   - success
17182 
   - ex
17183 
  """
17184 
 
17185 
  thrift_spec = (
17186 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17188 
  )
17189 
 
17190 
  def __init__(self, success=None, ex=None,):
17191 
    self.success = success
17192 
    self.ex = ex
17193 
 
17194 
  def read(self, iprot):
17195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17197 
      return
17198 
    iprot.readStructBegin()
17199 
    while True:
17200 
      (fname, ftype, fid) = iprot.readFieldBegin()
17201 
      if ftype == TType.STOP:
17202 
        break
17203 
      if fid == 0:
17204 
        if ftype == TType.STRUCT:
17205 
          self.success = Order()
17206 
          self.success.read(iprot)
17207 
        else:
17208 
          iprot.skip(ftype)
17209 
      elif fid == 1:
17210 
        if ftype == TType.STRUCT:
17211 
          self.ex = TransactionServiceException()
17212 
          self.ex.read(iprot)
17213 
        else:
17214 
          iprot.skip(ftype)
17215 
      else:
17216 
        iprot.skip(ftype)
17217 
      iprot.readFieldEnd()
17218 
    iprot.readStructEnd()
17219 
 
17220 
  def write(self, oprot):
17221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17223 
      return
17224 
    oprot.writeStructBegin('shiftToWarehouse_result')
17225 
    if self.success is not None:
17226 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17227 
      self.success.write(oprot)
17228 
      oprot.writeFieldEnd()
17229 
    if self.ex is not None:
17230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17231 
      self.ex.write(oprot)
17232 
      oprot.writeFieldEnd()
17233 
    oprot.writeFieldStop()
17234 
    oprot.writeStructEnd()
17235 
 
17236 
  def validate(self):
17237 
    return
17238 
 
17239 
 
17240 
  def __repr__(self):
17241 
    L = ['%s=%r' % (key, value)
17242 
      for key, value in self.__dict__.iteritems()]
17243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17244 
 
17245 
  def __eq__(self, other):
17246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17247 
 
17248 
  def __ne__(self, other):
17249 
    return not (self == other)
3553 chandransh 17250 
 
17251 
class addDelayReason_args:
17252 
  """
17253 
  Attributes:
17254 
   - orderId
17255 
   - delayReason
3986 chandransh 17256 
   - furtherDelay
4647 rajveer 17257 
   - delayReasonText
3553 chandransh 17258 
  """
17259 
 
17260 
  thrift_spec = (
17261 
    None, # 0
17262 
    (1, TType.I64, 'orderId', None, None, ), # 1
17263 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 17264 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 17265 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 17266 
  )
17267 
 
4647 rajveer 17268 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 17269 
    self.orderId = orderId
17270 
    self.delayReason = delayReason
3986 chandransh 17271 
    self.furtherDelay = furtherDelay
4647 rajveer 17272 
    self.delayReasonText = delayReasonText
3553 chandransh 17273 
 
17274 
  def read(self, iprot):
17275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17277 
      return
17278 
    iprot.readStructBegin()
17279 
    while True:
17280 
      (fname, ftype, fid) = iprot.readFieldBegin()
17281 
      if ftype == TType.STOP:
17282 
        break
17283 
      if fid == 1:
17284 
        if ftype == TType.I64:
17285 
          self.orderId = iprot.readI64();
17286 
        else:
17287 
          iprot.skip(ftype)
17288 
      elif fid == 2:
17289 
        if ftype == TType.I32:
17290 
          self.delayReason = iprot.readI32();
17291 
        else:
17292 
          iprot.skip(ftype)
3986 chandransh 17293 
      elif fid == 3:
17294 
        if ftype == TType.I64:
17295 
          self.furtherDelay = iprot.readI64();
17296 
        else:
17297 
          iprot.skip(ftype)
4647 rajveer 17298 
      elif fid == 4:
17299 
        if ftype == TType.STRING:
17300 
          self.delayReasonText = iprot.readString();
17301 
        else:
17302 
          iprot.skip(ftype)
3553 chandransh 17303 
      else:
17304 
        iprot.skip(ftype)
17305 
      iprot.readFieldEnd()
17306 
    iprot.readStructEnd()
17307 
 
17308 
  def write(self, oprot):
17309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17311 
      return
17312 
    oprot.writeStructBegin('addDelayReason_args')
17313 
    if self.orderId is not None:
17314 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17315 
      oprot.writeI64(self.orderId)
17316 
      oprot.writeFieldEnd()
17317 
    if self.delayReason is not None:
17318 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
17319 
      oprot.writeI32(self.delayReason)
17320 
      oprot.writeFieldEnd()
3986 chandransh 17321 
    if self.furtherDelay is not None:
17322 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
17323 
      oprot.writeI64(self.furtherDelay)
17324 
      oprot.writeFieldEnd()
4647 rajveer 17325 
    if self.delayReasonText is not None:
17326 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
17327 
      oprot.writeString(self.delayReasonText)
17328 
      oprot.writeFieldEnd()
3553 chandransh 17329 
    oprot.writeFieldStop()
17330 
    oprot.writeStructEnd()
17331 
 
17332 
  def validate(self):
17333 
    return
17334 
 
17335 
 
17336 
  def __repr__(self):
17337 
    L = ['%s=%r' % (key, value)
17338 
      for key, value in self.__dict__.iteritems()]
17339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17340 
 
17341 
  def __eq__(self, other):
17342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17343 
 
17344 
  def __ne__(self, other):
17345 
    return not (self == other)
17346 
 
17347 
class addDelayReason_result:
17348 
  """
17349 
  Attributes:
17350 
   - success
17351 
   - ex
17352 
  """
17353 
 
17354 
  thrift_spec = (
17355 
    (0, TType.BOOL, 'success', None, None, ), # 0
17356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17357 
  )
17358 
 
17359 
  def __init__(self, success=None, ex=None,):
17360 
    self.success = success
17361 
    self.ex = ex
17362 
 
17363 
  def read(self, iprot):
17364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17366 
      return
17367 
    iprot.readStructBegin()
17368 
    while True:
17369 
      (fname, ftype, fid) = iprot.readFieldBegin()
17370 
      if ftype == TType.STOP:
17371 
        break
17372 
      if fid == 0:
17373 
        if ftype == TType.BOOL:
17374 
          self.success = iprot.readBool();
17375 
        else:
17376 
          iprot.skip(ftype)
17377 
      elif fid == 1:
17378 
        if ftype == TType.STRUCT:
17379 
          self.ex = TransactionServiceException()
17380 
          self.ex.read(iprot)
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      else:
17384 
        iprot.skip(ftype)
17385 
      iprot.readFieldEnd()
17386 
    iprot.readStructEnd()
17387 
 
17388 
  def write(self, oprot):
17389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17391 
      return
17392 
    oprot.writeStructBegin('addDelayReason_result')
17393 
    if self.success is not None:
17394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17395 
      oprot.writeBool(self.success)
17396 
      oprot.writeFieldEnd()
17397 
    if self.ex is not None:
17398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17399 
      self.ex.write(oprot)
17400 
      oprot.writeFieldEnd()
17401 
    oprot.writeFieldStop()
17402 
    oprot.writeStructEnd()
17403 
 
17404 
  def validate(self):
17405 
    return
17406 
 
17407 
 
17408 
  def __repr__(self):
17409 
    L = ['%s=%r' % (key, value)
17410 
      for key, value in self.__dict__.iteritems()]
17411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17412 
 
17413 
  def __eq__(self, other):
17414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17415 
 
17416 
  def __ne__(self, other):
17417 
    return not (self == other)
3956 chandransh 17418 
 
17419 
class reconcileCodCollection_args:
17420 
  """
17421 
  Attributes:
17422 
   - collectedAmountMap
17423 
   - xferBy
17424 
   - xferTxnId
17425 
   - xferDate
17426 
  """
17427 
 
17428 
  thrift_spec = (
17429 
    None, # 0
17430 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17431 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17432 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17433 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17434 
  )
17435 
 
17436 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17437 
    self.collectedAmountMap = collectedAmountMap
17438 
    self.xferBy = xferBy
17439 
    self.xferTxnId = xferTxnId
17440 
    self.xferDate = xferDate
17441 
 
17442 
  def read(self, iprot):
17443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17445 
      return
17446 
    iprot.readStructBegin()
17447 
    while True:
17448 
      (fname, ftype, fid) = iprot.readFieldBegin()
17449 
      if ftype == TType.STOP:
17450 
        break
17451 
      if fid == 1:
17452 
        if ftype == TType.MAP:
17453 
          self.collectedAmountMap = {}
5411 rajveer 17454 
          (_ktype390, _vtype391, _size389 ) = iprot.readMapBegin()
17455 
          for _i393 in xrange(_size389):
17456 
            _key394 = iprot.readString();
17457 
            _val395 = iprot.readDouble();
17458 
            self.collectedAmountMap[_key394] = _val395
3956 chandransh 17459 
          iprot.readMapEnd()
17460 
        else:
17461 
          iprot.skip(ftype)
17462 
      elif fid == 2:
17463 
        if ftype == TType.STRING:
17464 
          self.xferBy = iprot.readString();
17465 
        else:
17466 
          iprot.skip(ftype)
17467 
      elif fid == 3:
17468 
        if ftype == TType.STRING:
17469 
          self.xferTxnId = iprot.readString();
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 4:
17473 
        if ftype == TType.I64:
17474 
          self.xferDate = iprot.readI64();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      else:
17478 
        iprot.skip(ftype)
17479 
      iprot.readFieldEnd()
17480 
    iprot.readStructEnd()
17481 
 
17482 
  def write(self, oprot):
17483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17485 
      return
17486 
    oprot.writeStructBegin('reconcileCodCollection_args')
17487 
    if self.collectedAmountMap is not None:
17488 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17489 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5411 rajveer 17490 
      for kiter396,viter397 in self.collectedAmountMap.items():
17491 
        oprot.writeString(kiter396)
17492 
        oprot.writeDouble(viter397)
3956 chandransh 17493 
      oprot.writeMapEnd()
17494 
      oprot.writeFieldEnd()
17495 
    if self.xferBy is not None:
17496 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17497 
      oprot.writeString(self.xferBy)
17498 
      oprot.writeFieldEnd()
17499 
    if self.xferTxnId is not None:
17500 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17501 
      oprot.writeString(self.xferTxnId)
17502 
      oprot.writeFieldEnd()
17503 
    if self.xferDate is not None:
17504 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17505 
      oprot.writeI64(self.xferDate)
17506 
      oprot.writeFieldEnd()
17507 
    oprot.writeFieldStop()
17508 
    oprot.writeStructEnd()
17509 
 
17510 
  def validate(self):
17511 
    return
17512 
 
17513 
 
17514 
  def __repr__(self):
17515 
    L = ['%s=%r' % (key, value)
17516 
      for key, value in self.__dict__.iteritems()]
17517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17518 
 
17519 
  def __eq__(self, other):
17520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17521 
 
17522 
  def __ne__(self, other):
17523 
    return not (self == other)
17524 
 
17525 
class reconcileCodCollection_result:
17526 
  """
17527 
  Attributes:
17528 
   - success
17529 
   - ex
17530 
  """
17531 
 
17532 
  thrift_spec = (
17533 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17534 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17535 
  )
17536 
 
17537 
  def __init__(self, success=None, ex=None,):
17538 
    self.success = success
17539 
    self.ex = ex
17540 
 
17541 
  def read(self, iprot):
17542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17544 
      return
17545 
    iprot.readStructBegin()
17546 
    while True:
17547 
      (fname, ftype, fid) = iprot.readFieldBegin()
17548 
      if ftype == TType.STOP:
17549 
        break
17550 
      if fid == 0:
17551 
        if ftype == TType.MAP:
17552 
          self.success = {}
5411 rajveer 17553 
          (_ktype399, _vtype400, _size398 ) = iprot.readMapBegin()
17554 
          for _i402 in xrange(_size398):
17555 
            _key403 = iprot.readString();
17556 
            _val404 = iprot.readString();
17557 
            self.success[_key403] = _val404
3956 chandransh 17558 
          iprot.readMapEnd()
17559 
        else:
17560 
          iprot.skip(ftype)
17561 
      elif fid == 1:
17562 
        if ftype == TType.STRUCT:
17563 
          self.ex = TransactionServiceException()
17564 
          self.ex.read(iprot)
17565 
        else:
17566 
          iprot.skip(ftype)
17567 
      else:
17568 
        iprot.skip(ftype)
17569 
      iprot.readFieldEnd()
17570 
    iprot.readStructEnd()
17571 
 
17572 
  def write(self, oprot):
17573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17575 
      return
17576 
    oprot.writeStructBegin('reconcileCodCollection_result')
17577 
    if self.success is not None:
17578 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17579 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5411 rajveer 17580 
      for kiter405,viter406 in self.success.items():
17581 
        oprot.writeString(kiter405)
17582 
        oprot.writeString(viter406)
3956 chandransh 17583 
      oprot.writeMapEnd()
17584 
      oprot.writeFieldEnd()
17585 
    if self.ex is not None:
17586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17587 
      self.ex.write(oprot)
17588 
      oprot.writeFieldEnd()
17589 
    oprot.writeFieldStop()
17590 
    oprot.writeStructEnd()
17591 
 
17592 
  def validate(self):
17593 
    return
17594 
 
17595 
 
17596 
  def __repr__(self):
17597 
    L = ['%s=%r' % (key, value)
17598 
      for key, value in self.__dict__.iteritems()]
17599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17600 
 
17601 
  def __eq__(self, other):
17602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17603 
 
17604 
  def __ne__(self, other):
17605 
    return not (self == other)
4008 mandeep.dh 17606 
 
17607 
class getTransactionsRequiringExtraProcessing_args:
17608 
  """
17609 
  Attributes:
17610 
   - category
17611 
  """
17612 
 
17613 
  thrift_spec = (
17614 
    None, # 0
17615 
    (1, TType.I32, 'category', None, None, ), # 1
17616 
  )
17617 
 
17618 
  def __init__(self, category=None,):
17619 
    self.category = category
17620 
 
17621 
  def read(self, iprot):
17622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17624 
      return
17625 
    iprot.readStructBegin()
17626 
    while True:
17627 
      (fname, ftype, fid) = iprot.readFieldBegin()
17628 
      if ftype == TType.STOP:
17629 
        break
17630 
      if fid == 1:
17631 
        if ftype == TType.I32:
17632 
          self.category = iprot.readI32();
17633 
        else:
17634 
          iprot.skip(ftype)
17635 
      else:
17636 
        iprot.skip(ftype)
17637 
      iprot.readFieldEnd()
17638 
    iprot.readStructEnd()
17639 
 
17640 
  def write(self, oprot):
17641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17643 
      return
17644 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17645 
    if self.category is not None:
17646 
      oprot.writeFieldBegin('category', TType.I32, 1)
17647 
      oprot.writeI32(self.category)
17648 
      oprot.writeFieldEnd()
17649 
    oprot.writeFieldStop()
17650 
    oprot.writeStructEnd()
17651 
 
17652 
  def validate(self):
17653 
    return
17654 
 
17655 
 
17656 
  def __repr__(self):
17657 
    L = ['%s=%r' % (key, value)
17658 
      for key, value in self.__dict__.iteritems()]
17659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17660 
 
17661 
  def __eq__(self, other):
17662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17663 
 
17664 
  def __ne__(self, other):
17665 
    return not (self == other)
17666 
 
17667 
class getTransactionsRequiringExtraProcessing_result:
17668 
  """
17669 
  Attributes:
17670 
   - success
17671 
  """
17672 
 
17673 
  thrift_spec = (
17674 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17675 
  )
17676 
 
17677 
  def __init__(self, success=None,):
17678 
    self.success = success
17679 
 
17680 
  def read(self, iprot):
17681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17683 
      return
17684 
    iprot.readStructBegin()
17685 
    while True:
17686 
      (fname, ftype, fid) = iprot.readFieldBegin()
17687 
      if ftype == TType.STOP:
17688 
        break
17689 
      if fid == 0:
17690 
        if ftype == TType.LIST:
17691 
          self.success = []
5411 rajveer 17692 
          (_etype410, _size407) = iprot.readListBegin()
17693 
          for _i411 in xrange(_size407):
17694 
            _elem412 = iprot.readI64();
17695 
            self.success.append(_elem412)
4008 mandeep.dh 17696 
          iprot.readListEnd()
17697 
        else:
17698 
          iprot.skip(ftype)
17699 
      else:
17700 
        iprot.skip(ftype)
17701 
      iprot.readFieldEnd()
17702 
    iprot.readStructEnd()
17703 
 
17704 
  def write(self, oprot):
17705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17707 
      return
17708 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17709 
    if self.success is not None:
17710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17711 
      oprot.writeListBegin(TType.I64, len(self.success))
5411 rajveer 17712 
      for iter413 in self.success:
17713 
        oprot.writeI64(iter413)
4008 mandeep.dh 17714 
      oprot.writeListEnd()
17715 
      oprot.writeFieldEnd()
17716 
    oprot.writeFieldStop()
17717 
    oprot.writeStructEnd()
17718 
 
17719 
  def validate(self):
17720 
    return
17721 
 
17722 
 
17723 
  def __repr__(self):
17724 
    L = ['%s=%r' % (key, value)
17725 
      for key, value in self.__dict__.iteritems()]
17726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17727 
 
17728 
  def __eq__(self, other):
17729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17730 
 
17731 
  def __ne__(self, other):
17732 
    return not (self == other)
17733 
 
17734 
class markTransactionAsProcessed_args:
17735 
  """
17736 
  Attributes:
17737 
   - transactionId
17738 
   - category
17739 
  """
17740 
 
17741 
  thrift_spec = (
17742 
    None, # 0
17743 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17744 
    (2, TType.I32, 'category', None, None, ), # 2
17745 
  )
17746 
 
17747 
  def __init__(self, transactionId=None, category=None,):
17748 
    self.transactionId = transactionId
17749 
    self.category = category
17750 
 
17751 
  def read(self, iprot):
17752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17754 
      return
17755 
    iprot.readStructBegin()
17756 
    while True:
17757 
      (fname, ftype, fid) = iprot.readFieldBegin()
17758 
      if ftype == TType.STOP:
17759 
        break
17760 
      if fid == 1:
17761 
        if ftype == TType.I64:
17762 
          self.transactionId = iprot.readI64();
17763 
        else:
17764 
          iprot.skip(ftype)
17765 
      elif fid == 2:
17766 
        if ftype == TType.I32:
17767 
          self.category = iprot.readI32();
17768 
        else:
17769 
          iprot.skip(ftype)
17770 
      else:
17771 
        iprot.skip(ftype)
17772 
      iprot.readFieldEnd()
17773 
    iprot.readStructEnd()
17774 
 
17775 
  def write(self, oprot):
17776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17778 
      return
17779 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17780 
    if self.transactionId is not None:
17781 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17782 
      oprot.writeI64(self.transactionId)
17783 
      oprot.writeFieldEnd()
17784 
    if self.category is not None:
17785 
      oprot.writeFieldBegin('category', TType.I32, 2)
17786 
      oprot.writeI32(self.category)
17787 
      oprot.writeFieldEnd()
17788 
    oprot.writeFieldStop()
17789 
    oprot.writeStructEnd()
17790 
 
17791 
  def validate(self):
17792 
    return
17793 
 
17794 
 
17795 
  def __repr__(self):
17796 
    L = ['%s=%r' % (key, value)
17797 
      for key, value in self.__dict__.iteritems()]
17798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17799 
 
17800 
  def __eq__(self, other):
17801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17802 
 
17803 
  def __ne__(self, other):
17804 
    return not (self == other)
17805 
 
17806 
class markTransactionAsProcessed_result:
17807 
 
17808 
  thrift_spec = (
17809 
  )
17810 
 
17811 
  def read(self, iprot):
17812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17814 
      return
17815 
    iprot.readStructBegin()
17816 
    while True:
17817 
      (fname, ftype, fid) = iprot.readFieldBegin()
17818 
      if ftype == TType.STOP:
17819 
        break
17820 
      else:
17821 
        iprot.skip(ftype)
17822 
      iprot.readFieldEnd()
17823 
    iprot.readStructEnd()
17824 
 
17825 
  def write(self, oprot):
17826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17828 
      return
17829 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17830 
    oprot.writeFieldStop()
17831 
    oprot.writeStructEnd()
17832 
 
17833 
  def validate(self):
17834 
    return
17835 
 
17836 
 
17837 
  def __repr__(self):
17838 
    L = ['%s=%r' % (key, value)
17839 
      for key, value in self.__dict__.iteritems()]
17840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17841 
 
17842 
  def __eq__(self, other):
17843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17844 
 
17845 
  def __ne__(self, other):
17846 
    return not (self == other)
4018 chandransh 17847 
 
17848 
class getItemWiseRiskyOrdersCount_args:
17849 
 
17850 
  thrift_spec = (
17851 
  )
17852 
 
17853 
  def read(self, iprot):
17854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17856 
      return
17857 
    iprot.readStructBegin()
17858 
    while True:
17859 
      (fname, ftype, fid) = iprot.readFieldBegin()
17860 
      if ftype == TType.STOP:
17861 
        break
17862 
      else:
17863 
        iprot.skip(ftype)
17864 
      iprot.readFieldEnd()
17865 
    iprot.readStructEnd()
17866 
 
17867 
  def write(self, oprot):
17868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17870 
      return
17871 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17872 
    oprot.writeFieldStop()
17873 
    oprot.writeStructEnd()
17874 
 
17875 
  def validate(self):
17876 
    return
17877 
 
17878 
 
17879 
  def __repr__(self):
17880 
    L = ['%s=%r' % (key, value)
17881 
      for key, value in self.__dict__.iteritems()]
17882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17883 
 
17884 
  def __eq__(self, other):
17885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17886 
 
17887 
  def __ne__(self, other):
17888 
    return not (self == other)
17889 
 
17890 
class getItemWiseRiskyOrdersCount_result:
17891 
  """
17892 
  Attributes:
17893 
   - success
17894 
  """
17895 
 
17896 
  thrift_spec = (
17897 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17898 
  )
17899 
 
17900 
  def __init__(self, success=None,):
17901 
    self.success = success
17902 
 
17903 
  def read(self, iprot):
17904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17906 
      return
17907 
    iprot.readStructBegin()
17908 
    while True:
17909 
      (fname, ftype, fid) = iprot.readFieldBegin()
17910 
      if ftype == TType.STOP:
17911 
        break
17912 
      if fid == 0:
17913 
        if ftype == TType.MAP:
17914 
          self.success = {}
5411 rajveer 17915 
          (_ktype415, _vtype416, _size414 ) = iprot.readMapBegin()
17916 
          for _i418 in xrange(_size414):
17917 
            _key419 = iprot.readI64();
17918 
            _val420 = iprot.readI64();
17919 
            self.success[_key419] = _val420
4018 chandransh 17920 
          iprot.readMapEnd()
17921 
        else:
17922 
          iprot.skip(ftype)
17923 
      else:
17924 
        iprot.skip(ftype)
17925 
      iprot.readFieldEnd()
17926 
    iprot.readStructEnd()
17927 
 
17928 
  def write(self, oprot):
17929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17931 
      return
17932 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17933 
    if self.success is not None:
17934 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17935 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5411 rajveer 17936 
      for kiter421,viter422 in self.success.items():
17937 
        oprot.writeI64(kiter421)
17938 
        oprot.writeI64(viter422)
4018 chandransh 17939 
      oprot.writeMapEnd()
17940 
      oprot.writeFieldEnd()
17941 
    oprot.writeFieldStop()
17942 
    oprot.writeStructEnd()
17943 
 
17944 
  def validate(self):
17945 
    return
17946 
 
17947 
 
17948 
  def __repr__(self):
17949 
    L = ['%s=%r' % (key, value)
17950 
      for key, value in self.__dict__.iteritems()]
17951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17952 
 
17953 
  def __eq__(self, other):
17954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17955 
 
17956 
  def __ne__(self, other):
17957 
    return not (self == other)
4247 rajveer 17958 
 
4295 varun.gupt 17959 
class getOrdersForItemIds_args:
17960 
  """
17961 
  Attributes:
17962 
   - itemIds
17963 
  """
17964 
 
17965 
  thrift_spec = (
17966 
    None, # 0
17967 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17968 
  )
17969 
 
17970 
  def __init__(self, itemIds=None,):
17971 
    self.itemIds = itemIds
17972 
 
17973 
  def read(self, iprot):
17974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17976 
      return
17977 
    iprot.readStructBegin()
17978 
    while True:
17979 
      (fname, ftype, fid) = iprot.readFieldBegin()
17980 
      if ftype == TType.STOP:
17981 
        break
17982 
      if fid == 1:
17983 
        if ftype == TType.LIST:
17984 
          self.itemIds = []
5411 rajveer 17985 
          (_etype426, _size423) = iprot.readListBegin()
17986 
          for _i427 in xrange(_size423):
17987 
            _elem428 = iprot.readI64();
17988 
            self.itemIds.append(_elem428)
4295 varun.gupt 17989 
          iprot.readListEnd()
17990 
        else:
17991 
          iprot.skip(ftype)
17992 
      else:
17993 
        iprot.skip(ftype)
17994 
      iprot.readFieldEnd()
17995 
    iprot.readStructEnd()
17996 
 
17997 
  def write(self, oprot):
17998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18000 
      return
18001 
    oprot.writeStructBegin('getOrdersForItemIds_args')
18002 
    if self.itemIds is not None:
18003 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18004 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5411 rajveer 18005 
      for iter429 in self.itemIds:
18006 
        oprot.writeI64(iter429)
4295 varun.gupt 18007 
      oprot.writeListEnd()
18008 
      oprot.writeFieldEnd()
18009 
    oprot.writeFieldStop()
18010 
    oprot.writeStructEnd()
18011 
 
18012 
  def validate(self):
18013 
    return
18014 
 
18015 
 
18016 
  def __repr__(self):
18017 
    L = ['%s=%r' % (key, value)
18018 
      for key, value in self.__dict__.iteritems()]
18019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18020 
 
18021 
  def __eq__(self, other):
18022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18023 
 
18024 
  def __ne__(self, other):
18025 
    return not (self == other)
18026 
 
18027 
class getOrdersForItemIds_result:
18028 
  """
18029 
  Attributes:
18030 
   - success
18031 
  """
18032 
 
18033 
  thrift_spec = (
18034 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18035 
  )
18036 
 
18037 
  def __init__(self, success=None,):
18038 
    self.success = success
18039 
 
18040 
  def read(self, iprot):
18041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18043 
      return
18044 
    iprot.readStructBegin()
18045 
    while True:
18046 
      (fname, ftype, fid) = iprot.readFieldBegin()
18047 
      if ftype == TType.STOP:
18048 
        break
18049 
      if fid == 0:
18050 
        if ftype == TType.LIST:
18051 
          self.success = []
5411 rajveer 18052 
          (_etype433, _size430) = iprot.readListBegin()
18053 
          for _i434 in xrange(_size430):
18054 
            _elem435 = Order()
18055 
            _elem435.read(iprot)
18056 
            self.success.append(_elem435)
4295 varun.gupt 18057 
          iprot.readListEnd()
18058 
        else:
18059 
          iprot.skip(ftype)
18060 
      else:
18061 
        iprot.skip(ftype)
18062 
      iprot.readFieldEnd()
18063 
    iprot.readStructEnd()
18064 
 
18065 
  def write(self, oprot):
18066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18068 
      return
18069 
    oprot.writeStructBegin('getOrdersForItemIds_result')
18070 
    if self.success is not None:
18071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18072 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 18073 
      for iter436 in self.success:
18074 
        iter436.write(oprot)
4295 varun.gupt 18075 
      oprot.writeListEnd()
18076 
      oprot.writeFieldEnd()
18077 
    oprot.writeFieldStop()
18078 
    oprot.writeStructEnd()
18079 
 
18080 
  def validate(self):
18081 
    return
18082 
 
18083 
 
18084 
  def __repr__(self):
18085 
    L = ['%s=%r' % (key, value)
18086 
      for key, value in self.__dict__.iteritems()]
18087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18088 
 
18089 
  def __eq__(self, other):
18090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18091 
 
18092 
  def __ne__(self, other):
18093 
    return not (self == other)
18094 
 
4247 rajveer 18095 
class markOrderCancellationRequestReceived_args:
18096 
  """
18097 
  Attributes:
18098 
   - orderId
18099 
  """
18100 
 
18101 
  thrift_spec = (
18102 
    None, # 0
18103 
    (1, TType.I64, 'orderId', None, None, ), # 1
18104 
  )
18105 
 
18106 
  def __init__(self, orderId=None,):
18107 
    self.orderId = orderId
18108 
 
18109 
  def read(self, iprot):
18110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18112 
      return
18113 
    iprot.readStructBegin()
18114 
    while True:
18115 
      (fname, ftype, fid) = iprot.readFieldBegin()
18116 
      if ftype == TType.STOP:
18117 
        break
18118 
      if fid == 1:
18119 
        if ftype == TType.I64:
18120 
          self.orderId = iprot.readI64();
18121 
        else:
18122 
          iprot.skip(ftype)
18123 
      else:
18124 
        iprot.skip(ftype)
18125 
      iprot.readFieldEnd()
18126 
    iprot.readStructEnd()
18127 
 
18128 
  def write(self, oprot):
18129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18131 
      return
18132 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
18133 
    if self.orderId is not None:
18134 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18135 
      oprot.writeI64(self.orderId)
18136 
      oprot.writeFieldEnd()
18137 
    oprot.writeFieldStop()
18138 
    oprot.writeStructEnd()
18139 
 
18140 
  def validate(self):
18141 
    return
18142 
 
18143 
 
18144 
  def __repr__(self):
18145 
    L = ['%s=%r' % (key, value)
18146 
      for key, value in self.__dict__.iteritems()]
18147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18148 
 
18149 
  def __eq__(self, other):
18150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18151 
 
18152 
  def __ne__(self, other):
18153 
    return not (self == other)
18154 
 
18155 
class markOrderCancellationRequestReceived_result:
18156 
  """
18157 
  Attributes:
18158 
   - ex
18159 
  """
18160 
 
18161 
  thrift_spec = (
18162 
    None, # 0
18163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18164 
  )
18165 
 
18166 
  def __init__(self, ex=None,):
18167 
    self.ex = ex
18168 
 
18169 
  def read(self, iprot):
18170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18172 
      return
18173 
    iprot.readStructBegin()
18174 
    while True:
18175 
      (fname, ftype, fid) = iprot.readFieldBegin()
18176 
      if ftype == TType.STOP:
18177 
        break
18178 
      if fid == 1:
18179 
        if ftype == TType.STRUCT:
18180 
          self.ex = TransactionServiceException()
18181 
          self.ex.read(iprot)
18182 
        else:
18183 
          iprot.skip(ftype)
18184 
      else:
18185 
        iprot.skip(ftype)
18186 
      iprot.readFieldEnd()
18187 
    iprot.readStructEnd()
18188 
 
18189 
  def write(self, oprot):
18190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18192 
      return
18193 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
18194 
    if self.ex is not None:
18195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18196 
      self.ex.write(oprot)
18197 
      oprot.writeFieldEnd()
18198 
    oprot.writeFieldStop()
18199 
    oprot.writeStructEnd()
18200 
 
18201 
  def validate(self):
18202 
    return
18203 
 
18204 
 
18205 
  def __repr__(self):
18206 
    L = ['%s=%r' % (key, value)
18207 
      for key, value in self.__dict__.iteritems()]
18208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18209 
 
18210 
  def __eq__(self, other):
18211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18212 
 
18213 
  def __ne__(self, other):
18214 
    return not (self == other)
18215 
 
18216 
class markOrderCancellationRequestConfirmed_args:
18217 
  """
18218 
  Attributes:
18219 
   - orderId
18220 
  """
18221 
 
18222 
  thrift_spec = (
18223 
    None, # 0
18224 
    (1, TType.I64, 'orderId', None, None, ), # 1
18225 
  )
18226 
 
18227 
  def __init__(self, orderId=None,):
18228 
    self.orderId = orderId
18229 
 
18230 
  def read(self, iprot):
18231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18233 
      return
18234 
    iprot.readStructBegin()
18235 
    while True:
18236 
      (fname, ftype, fid) = iprot.readFieldBegin()
18237 
      if ftype == TType.STOP:
18238 
        break
18239 
      if fid == 1:
18240 
        if ftype == TType.I64:
18241 
          self.orderId = iprot.readI64();
18242 
        else:
18243 
          iprot.skip(ftype)
18244 
      else:
18245 
        iprot.skip(ftype)
18246 
      iprot.readFieldEnd()
18247 
    iprot.readStructEnd()
18248 
 
18249 
  def write(self, oprot):
18250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18252 
      return
18253 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
18254 
    if self.orderId is not None:
18255 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18256 
      oprot.writeI64(self.orderId)
18257 
      oprot.writeFieldEnd()
18258 
    oprot.writeFieldStop()
18259 
    oprot.writeStructEnd()
18260 
 
18261 
  def validate(self):
18262 
    return
18263 
 
18264 
 
18265 
  def __repr__(self):
18266 
    L = ['%s=%r' % (key, value)
18267 
      for key, value in self.__dict__.iteritems()]
18268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18269 
 
18270 
  def __eq__(self, other):
18271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18272 
 
18273 
  def __ne__(self, other):
18274 
    return not (self == other)
18275 
 
18276 
class markOrderCancellationRequestConfirmed_result:
18277 
  """
18278 
  Attributes:
18279 
   - ex
18280 
  """
18281 
 
18282 
  thrift_spec = (
18283 
    None, # 0
18284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18285 
  )
18286 
 
18287 
  def __init__(self, ex=None,):
18288 
    self.ex = ex
18289 
 
18290 
  def read(self, iprot):
18291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18293 
      return
18294 
    iprot.readStructBegin()
18295 
    while True:
18296 
      (fname, ftype, fid) = iprot.readFieldBegin()
18297 
      if ftype == TType.STOP:
18298 
        break
18299 
      if fid == 1:
18300 
        if ftype == TType.STRUCT:
18301 
          self.ex = TransactionServiceException()
18302 
          self.ex.read(iprot)
18303 
        else:
18304 
          iprot.skip(ftype)
18305 
      else:
18306 
        iprot.skip(ftype)
18307 
      iprot.readFieldEnd()
18308 
    iprot.readStructEnd()
18309 
 
18310 
  def write(self, oprot):
18311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18313 
      return
18314 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
18315 
    if self.ex is not None:
18316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18317 
      self.ex.write(oprot)
18318 
      oprot.writeFieldEnd()
18319 
    oprot.writeFieldStop()
18320 
    oprot.writeStructEnd()
18321 
 
18322 
  def validate(self):
18323 
    return
18324 
 
18325 
 
18326 
  def __repr__(self):
18327 
    L = ['%s=%r' % (key, value)
18328 
      for key, value in self.__dict__.iteritems()]
18329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18330 
 
18331 
  def __eq__(self, other):
18332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18333 
 
18334 
  def __ne__(self, other):
18335 
    return not (self == other)
18336 
 
18337 
class markOrderCancellationRequestDenied_args:
18338 
  """
18339 
  Attributes:
18340 
   - orderId
18341 
  """
18342 
 
18343 
  thrift_spec = (
18344 
    None, # 0
18345 
    (1, TType.I64, 'orderId', None, None, ), # 1
18346 
  )
18347 
 
18348 
  def __init__(self, orderId=None,):
18349 
    self.orderId = orderId
18350 
 
18351 
  def read(self, iprot):
18352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18354 
      return
18355 
    iprot.readStructBegin()
18356 
    while True:
18357 
      (fname, ftype, fid) = iprot.readFieldBegin()
18358 
      if ftype == TType.STOP:
18359 
        break
18360 
      if fid == 1:
18361 
        if ftype == TType.I64:
18362 
          self.orderId = iprot.readI64();
18363 
        else:
18364 
          iprot.skip(ftype)
18365 
      else:
18366 
        iprot.skip(ftype)
18367 
      iprot.readFieldEnd()
18368 
    iprot.readStructEnd()
18369 
 
18370 
  def write(self, oprot):
18371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18373 
      return
18374 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18375 
    if self.orderId is not None:
18376 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18377 
      oprot.writeI64(self.orderId)
18378 
      oprot.writeFieldEnd()
18379 
    oprot.writeFieldStop()
18380 
    oprot.writeStructEnd()
18381 
 
18382 
  def validate(self):
18383 
    return
18384 
 
18385 
 
18386 
  def __repr__(self):
18387 
    L = ['%s=%r' % (key, value)
18388 
      for key, value in self.__dict__.iteritems()]
18389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18390 
 
18391 
  def __eq__(self, other):
18392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18393 
 
18394 
  def __ne__(self, other):
18395 
    return not (self == other)
18396 
 
18397 
class markOrderCancellationRequestDenied_result:
18398 
  """
18399 
  Attributes:
18400 
   - ex
18401 
  """
18402 
 
18403 
  thrift_spec = (
18404 
    None, # 0
18405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18406 
  )
18407 
 
18408 
  def __init__(self, ex=None,):
18409 
    self.ex = ex
18410 
 
18411 
  def read(self, iprot):
18412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18414 
      return
18415 
    iprot.readStructBegin()
18416 
    while True:
18417 
      (fname, ftype, fid) = iprot.readFieldBegin()
18418 
      if ftype == TType.STOP:
18419 
        break
18420 
      if fid == 1:
18421 
        if ftype == TType.STRUCT:
18422 
          self.ex = TransactionServiceException()
18423 
          self.ex.read(iprot)
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      else:
18427 
        iprot.skip(ftype)
18428 
      iprot.readFieldEnd()
18429 
    iprot.readStructEnd()
18430 
 
18431 
  def write(self, oprot):
18432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18434 
      return
18435 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18436 
    if self.ex is not None:
18437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18438 
      self.ex.write(oprot)
18439 
      oprot.writeFieldEnd()
18440 
    oprot.writeFieldStop()
18441 
    oprot.writeStructEnd()
18442 
 
18443 
  def validate(self):
18444 
    return
18445 
 
18446 
 
18447 
  def __repr__(self):
18448 
    L = ['%s=%r' % (key, value)
18449 
      for key, value in self.__dict__.iteritems()]
18450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18451 
 
18452 
  def __eq__(self, other):
18453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18454 
 
18455 
  def __ne__(self, other):
18456 
    return not (self == other)
18457 
 
4258 rajveer 18458 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18459 
  """
18460 
  Attributes:
4258 rajveer 18461 
   - transactionId
4247 rajveer 18462 
  """
18463 
 
18464 
  thrift_spec = (
18465 
    None, # 0
4258 rajveer 18466 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18467 
  )
18468 
 
4258 rajveer 18469 
  def __init__(self, transactionId=None,):
18470 
    self.transactionId = transactionId
4247 rajveer 18471 
 
18472 
  def read(self, iprot):
18473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18475 
      return
18476 
    iprot.readStructBegin()
18477 
    while True:
18478 
      (fname, ftype, fid) = iprot.readFieldBegin()
18479 
      if ftype == TType.STOP:
18480 
        break
18481 
      if fid == 1:
18482 
        if ftype == TType.I64:
4258 rajveer 18483 
          self.transactionId = iprot.readI64();
4247 rajveer 18484 
        else:
18485 
          iprot.skip(ftype)
18486 
      else:
18487 
        iprot.skip(ftype)
18488 
      iprot.readFieldEnd()
18489 
    iprot.readStructEnd()
18490 
 
18491 
  def write(self, oprot):
18492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18494 
      return
4258 rajveer 18495 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18496 
    if self.transactionId is not None:
18497 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18498 
      oprot.writeI64(self.transactionId)
4247 rajveer 18499 
      oprot.writeFieldEnd()
18500 
    oprot.writeFieldStop()
18501 
    oprot.writeStructEnd()
18502 
 
18503 
  def validate(self):
18504 
    return
18505 
 
18506 
 
18507 
  def __repr__(self):
18508 
    L = ['%s=%r' % (key, value)
18509 
      for key, value in self.__dict__.iteritems()]
18510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18511 
 
18512 
  def __eq__(self, other):
18513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18514 
 
18515 
  def __ne__(self, other):
18516 
    return not (self == other)
18517 
 
4258 rajveer 18518 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18519 
  """
18520 
  Attributes:
18521 
   - ex
18522 
  """
18523 
 
18524 
  thrift_spec = (
18525 
    None, # 0
18526 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18527 
  )
18528 
 
18529 
  def __init__(self, ex=None,):
18530 
    self.ex = ex
18531 
 
18532 
  def read(self, iprot):
18533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18535 
      return
18536 
    iprot.readStructBegin()
18537 
    while True:
18538 
      (fname, ftype, fid) = iprot.readFieldBegin()
18539 
      if ftype == TType.STOP:
18540 
        break
18541 
      if fid == 1:
18542 
        if ftype == TType.STRUCT:
18543 
          self.ex = TransactionServiceException()
18544 
          self.ex.read(iprot)
18545 
        else:
18546 
          iprot.skip(ftype)
18547 
      else:
18548 
        iprot.skip(ftype)
18549 
      iprot.readFieldEnd()
18550 
    iprot.readStructEnd()
18551 
 
18552 
  def write(self, oprot):
18553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18555 
      return
4258 rajveer 18556 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18557 
    if self.ex is not None:
18558 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18559 
      self.ex.write(oprot)
18560 
      oprot.writeFieldEnd()
18561 
    oprot.writeFieldStop()
18562 
    oprot.writeStructEnd()
18563 
 
18564 
  def validate(self):
18565 
    return
18566 
 
18567 
 
18568 
  def __repr__(self):
18569 
    L = ['%s=%r' % (key, value)
18570 
      for key, value in self.__dict__.iteritems()]
18571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18572 
 
18573 
  def __eq__(self, other):
18574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18575 
 
18576 
  def __ne__(self, other):
18577 
    return not (self == other)
4259 anupam.sin 18578 
 
18579 
class refundTransaction_args:
18580 
  """
18581 
  Attributes:
18582 
   - transactionId
18583 
   - refundedBy
18584 
   - reason
18585 
  """
18586 
 
18587 
  thrift_spec = (
18588 
    None, # 0
18589 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18590 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18591 
    (3, TType.STRING, 'reason', None, None, ), # 3
18592 
  )
18593 
 
18594 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18595 
    self.transactionId = transactionId
18596 
    self.refundedBy = refundedBy
18597 
    self.reason = reason
18598 
 
18599 
  def read(self, iprot):
18600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18602 
      return
18603 
    iprot.readStructBegin()
18604 
    while True:
18605 
      (fname, ftype, fid) = iprot.readFieldBegin()
18606 
      if ftype == TType.STOP:
18607 
        break
18608 
      if fid == 1:
18609 
        if ftype == TType.I64:
18610 
          self.transactionId = iprot.readI64();
18611 
        else:
18612 
          iprot.skip(ftype)
18613 
      elif fid == 2:
18614 
        if ftype == TType.STRING:
18615 
          self.refundedBy = iprot.readString();
18616 
        else:
18617 
          iprot.skip(ftype)
18618 
      elif fid == 3:
18619 
        if ftype == TType.STRING:
18620 
          self.reason = iprot.readString();
18621 
        else:
18622 
          iprot.skip(ftype)
18623 
      else:
18624 
        iprot.skip(ftype)
18625 
      iprot.readFieldEnd()
18626 
    iprot.readStructEnd()
18627 
 
18628 
  def write(self, oprot):
18629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18631 
      return
18632 
    oprot.writeStructBegin('refundTransaction_args')
18633 
    if self.transactionId is not None:
18634 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18635 
      oprot.writeI64(self.transactionId)
18636 
      oprot.writeFieldEnd()
18637 
    if self.refundedBy is not None:
18638 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18639 
      oprot.writeString(self.refundedBy)
18640 
      oprot.writeFieldEnd()
18641 
    if self.reason is not None:
18642 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18643 
      oprot.writeString(self.reason)
18644 
      oprot.writeFieldEnd()
18645 
    oprot.writeFieldStop()
18646 
    oprot.writeStructEnd()
18647 
 
18648 
  def validate(self):
18649 
    return
18650 
 
18651 
 
18652 
  def __repr__(self):
18653 
    L = ['%s=%r' % (key, value)
18654 
      for key, value in self.__dict__.iteritems()]
18655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18656 
 
18657 
  def __eq__(self, other):
18658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18659 
 
18660 
  def __ne__(self, other):
18661 
    return not (self == other)
18662 
 
18663 
class refundTransaction_result:
18664 
  """
18665 
  Attributes:
18666 
   - ex
18667 
  """
18668 
 
18669 
  thrift_spec = (
18670 
    None, # 0
18671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18672 
  )
18673 
 
18674 
  def __init__(self, ex=None,):
18675 
    self.ex = ex
18676 
 
18677 
  def read(self, iprot):
18678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18680 
      return
18681 
    iprot.readStructBegin()
18682 
    while True:
18683 
      (fname, ftype, fid) = iprot.readFieldBegin()
18684 
      if ftype == TType.STOP:
18685 
        break
18686 
      if fid == 1:
18687 
        if ftype == TType.STRUCT:
18688 
          self.ex = TransactionServiceException()
18689 
          self.ex.read(iprot)
18690 
        else:
18691 
          iprot.skip(ftype)
18692 
      else:
18693 
        iprot.skip(ftype)
18694 
      iprot.readFieldEnd()
18695 
    iprot.readStructEnd()
18696 
 
18697 
  def write(self, oprot):
18698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18700 
      return
18701 
    oprot.writeStructBegin('refundTransaction_result')
18702 
    if self.ex is not None:
18703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18704 
      self.ex.write(oprot)
18705 
      oprot.writeFieldEnd()
18706 
    oprot.writeFieldStop()
18707 
    oprot.writeStructEnd()
18708 
 
18709 
  def validate(self):
18710 
    return
18711 
 
18712 
 
18713 
  def __repr__(self):
18714 
    L = ['%s=%r' % (key, value)
18715 
      for key, value in self.__dict__.iteritems()]
18716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18717 
 
18718 
  def __eq__(self, other):
18719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18720 
 
18721 
  def __ne__(self, other):
18722 
    return not (self == other)
4285 rajveer 18723 
 
4324 mandeep.dh 18724 
class updateShipmentAddress_args:
18725 
  """
18726 
  Attributes:
18727 
   - orderId
18728 
   - addressId
18729 
  """
18730 
 
18731 
  thrift_spec = (
18732 
    None, # 0
18733 
    (1, TType.I64, 'orderId', None, None, ), # 1
18734 
    (2, TType.I64, 'addressId', None, None, ), # 2
18735 
  )
18736 
 
18737 
  def __init__(self, orderId=None, addressId=None,):
18738 
    self.orderId = orderId
18739 
    self.addressId = addressId
18740 
 
18741 
  def read(self, iprot):
18742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18744 
      return
18745 
    iprot.readStructBegin()
18746 
    while True:
18747 
      (fname, ftype, fid) = iprot.readFieldBegin()
18748 
      if ftype == TType.STOP:
18749 
        break
18750 
      if fid == 1:
18751 
        if ftype == TType.I64:
18752 
          self.orderId = iprot.readI64();
18753 
        else:
18754 
          iprot.skip(ftype)
18755 
      elif fid == 2:
18756 
        if ftype == TType.I64:
18757 
          self.addressId = iprot.readI64();
18758 
        else:
18759 
          iprot.skip(ftype)
18760 
      else:
18761 
        iprot.skip(ftype)
18762 
      iprot.readFieldEnd()
18763 
    iprot.readStructEnd()
18764 
 
18765 
  def write(self, oprot):
18766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18768 
      return
18769 
    oprot.writeStructBegin('updateShipmentAddress_args')
18770 
    if self.orderId is not None:
18771 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18772 
      oprot.writeI64(self.orderId)
18773 
      oprot.writeFieldEnd()
18774 
    if self.addressId is not None:
18775 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18776 
      oprot.writeI64(self.addressId)
18777 
      oprot.writeFieldEnd()
18778 
    oprot.writeFieldStop()
18779 
    oprot.writeStructEnd()
18780 
 
18781 
  def validate(self):
18782 
    return
18783 
 
18784 
 
18785 
  def __repr__(self):
18786 
    L = ['%s=%r' % (key, value)
18787 
      for key, value in self.__dict__.iteritems()]
18788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18789 
 
18790 
  def __eq__(self, other):
18791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18792 
 
18793 
  def __ne__(self, other):
18794 
    return not (self == other)
18795 
 
18796 
class updateShipmentAddress_result:
18797 
  """
18798 
  Attributes:
18799 
   - ex
18800 
  """
18801 
 
18802 
  thrift_spec = (
18803 
    None, # 0
18804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18805 
  )
18806 
 
18807 
  def __init__(self, ex=None,):
18808 
    self.ex = ex
18809 
 
18810 
  def read(self, iprot):
18811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18813 
      return
18814 
    iprot.readStructBegin()
18815 
    while True:
18816 
      (fname, ftype, fid) = iprot.readFieldBegin()
18817 
      if ftype == TType.STOP:
18818 
        break
18819 
      if fid == 1:
18820 
        if ftype == TType.STRUCT:
18821 
          self.ex = TransactionServiceException()
18822 
          self.ex.read(iprot)
18823 
        else:
18824 
          iprot.skip(ftype)
18825 
      else:
18826 
        iprot.skip(ftype)
18827 
      iprot.readFieldEnd()
18828 
    iprot.readStructEnd()
18829 
 
18830 
  def write(self, oprot):
18831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18833 
      return
18834 
    oprot.writeStructBegin('updateShipmentAddress_result')
18835 
    if self.ex is not None:
18836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18837 
      self.ex.write(oprot)
18838 
      oprot.writeFieldEnd()
18839 
    oprot.writeFieldStop()
18840 
    oprot.writeStructEnd()
18841 
 
18842 
  def validate(self):
18843 
    return
18844 
 
18845 
 
18846 
  def __repr__(self):
18847 
    L = ['%s=%r' % (key, value)
18848 
      for key, value in self.__dict__.iteritems()]
18849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18850 
 
18851 
  def __eq__(self, other):
18852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18853 
 
18854 
  def __ne__(self, other):
18855 
    return not (self == other)
18856 
 
4285 rajveer 18857 
class acceptOrdersForItemId_args:
18858 
  """
18859 
  Attributes:
18860 
   - itemId
18861 
   - inventory
18862 
  """
18863 
 
18864 
  thrift_spec = (
18865 
    None, # 0
18866 
    (1, TType.I64, 'itemId', None, None, ), # 1
18867 
    (2, TType.I64, 'inventory', None, None, ), # 2
18868 
  )
18869 
 
18870 
  def __init__(self, itemId=None, inventory=None,):
18871 
    self.itemId = itemId
18872 
    self.inventory = inventory
18873 
 
18874 
  def read(self, iprot):
18875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18877 
      return
18878 
    iprot.readStructBegin()
18879 
    while True:
18880 
      (fname, ftype, fid) = iprot.readFieldBegin()
18881 
      if ftype == TType.STOP:
18882 
        break
18883 
      if fid == 1:
18884 
        if ftype == TType.I64:
18885 
          self.itemId = iprot.readI64();
18886 
        else:
18887 
          iprot.skip(ftype)
18888 
      elif fid == 2:
18889 
        if ftype == TType.I64:
18890 
          self.inventory = iprot.readI64();
18891 
        else:
18892 
          iprot.skip(ftype)
18893 
      else:
18894 
        iprot.skip(ftype)
18895 
      iprot.readFieldEnd()
18896 
    iprot.readStructEnd()
18897 
 
18898 
  def write(self, oprot):
18899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18901 
      return
18902 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18903 
    if self.itemId is not None:
18904 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18905 
      oprot.writeI64(self.itemId)
18906 
      oprot.writeFieldEnd()
18907 
    if self.inventory is not None:
18908 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18909 
      oprot.writeI64(self.inventory)
18910 
      oprot.writeFieldEnd()
18911 
    oprot.writeFieldStop()
18912 
    oprot.writeStructEnd()
18913 
 
18914 
  def validate(self):
18915 
    return
18916 
 
18917 
 
18918 
  def __repr__(self):
18919 
    L = ['%s=%r' % (key, value)
18920 
      for key, value in self.__dict__.iteritems()]
18921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18922 
 
18923 
  def __eq__(self, other):
18924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18925 
 
18926 
  def __ne__(self, other):
18927 
    return not (self == other)
18928 
 
18929 
class acceptOrdersForItemId_result:
18930 
  """
18931 
  Attributes:
18932 
   - success
18933 
   - ex
18934 
  """
18935 
 
18936 
  thrift_spec = (
18937 
    (0, TType.BOOL, 'success', None, None, ), # 0
18938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18939 
  )
18940 
 
18941 
  def __init__(self, success=None, ex=None,):
18942 
    self.success = success
18943 
    self.ex = ex
18944 
 
18945 
  def read(self, iprot):
18946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18948 
      return
18949 
    iprot.readStructBegin()
18950 
    while True:
18951 
      (fname, ftype, fid) = iprot.readFieldBegin()
18952 
      if ftype == TType.STOP:
18953 
        break
18954 
      if fid == 0:
18955 
        if ftype == TType.BOOL:
18956 
          self.success = iprot.readBool();
18957 
        else:
18958 
          iprot.skip(ftype)
18959 
      elif fid == 1:
18960 
        if ftype == TType.STRUCT:
18961 
          self.ex = TransactionServiceException()
18962 
          self.ex.read(iprot)
18963 
        else:
18964 
          iprot.skip(ftype)
18965 
      else:
18966 
        iprot.skip(ftype)
18967 
      iprot.readFieldEnd()
18968 
    iprot.readStructEnd()
18969 
 
18970 
  def write(self, oprot):
18971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18973 
      return
18974 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18975 
    if self.success is not None:
18976 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18977 
      oprot.writeBool(self.success)
18978 
      oprot.writeFieldEnd()
18979 
    if self.ex is not None:
18980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18981 
      self.ex.write(oprot)
18982 
      oprot.writeFieldEnd()
18983 
    oprot.writeFieldStop()
18984 
    oprot.writeStructEnd()
18985 
 
18986 
  def validate(self):
18987 
    return
18988 
 
18989 
 
18990 
  def __repr__(self):
18991 
    L = ['%s=%r' % (key, value)
18992 
      for key, value in self.__dict__.iteritems()]
18993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18994 
 
18995 
  def __eq__(self, other):
18996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18997 
 
18998 
  def __ne__(self, other):
18999 
    return not (self == other)
4303 rajveer 19000 
 
19001 
class markOrdersAsPORaised_args:
19002 
  """
19003 
  Attributes:
19004 
   - vendorId
19005 
   - itemId
19006 
   - quantity
19007 
   - estimate
4369 rajveer 19008 
   - isReminder
4303 rajveer 19009 
  """
19010 
 
19011 
  thrift_spec = (
19012 
    None, # 0
19013 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19014 
    (2, TType.I64, 'itemId', None, None, ), # 2
19015 
    (3, TType.I64, 'quantity', None, None, ), # 3
19016 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19017 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19018 
  )
19019 
 
4369 rajveer 19020 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19021 
    self.vendorId = vendorId
19022 
    self.itemId = itemId
19023 
    self.quantity = quantity
19024 
    self.estimate = estimate
4369 rajveer 19025 
    self.isReminder = isReminder
4303 rajveer 19026 
 
19027 
  def read(self, iprot):
19028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19030 
      return
19031 
    iprot.readStructBegin()
19032 
    while True:
19033 
      (fname, ftype, fid) = iprot.readFieldBegin()
19034 
      if ftype == TType.STOP:
19035 
        break
19036 
      if fid == 1:
19037 
        if ftype == TType.I64:
19038 
          self.vendorId = iprot.readI64();
19039 
        else:
19040 
          iprot.skip(ftype)
19041 
      elif fid == 2:
19042 
        if ftype == TType.I64:
19043 
          self.itemId = iprot.readI64();
19044 
        else:
19045 
          iprot.skip(ftype)
19046 
      elif fid == 3:
19047 
        if ftype == TType.I64:
19048 
          self.quantity = iprot.readI64();
19049 
        else:
19050 
          iprot.skip(ftype)
19051 
      elif fid == 4:
19052 
        if ftype == TType.I64:
19053 
          self.estimate = iprot.readI64();
19054 
        else:
19055 
          iprot.skip(ftype)
4369 rajveer 19056 
      elif fid == 5:
19057 
        if ftype == TType.BOOL:
19058 
          self.isReminder = iprot.readBool();
19059 
        else:
19060 
          iprot.skip(ftype)
4303 rajveer 19061 
      else:
19062 
        iprot.skip(ftype)
19063 
      iprot.readFieldEnd()
19064 
    iprot.readStructEnd()
19065 
 
19066 
  def write(self, oprot):
19067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19069 
      return
19070 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
19071 
    if self.vendorId is not None:
19072 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19073 
      oprot.writeI64(self.vendorId)
19074 
      oprot.writeFieldEnd()
19075 
    if self.itemId is not None:
19076 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19077 
      oprot.writeI64(self.itemId)
19078 
      oprot.writeFieldEnd()
19079 
    if self.quantity is not None:
19080 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19081 
      oprot.writeI64(self.quantity)
19082 
      oprot.writeFieldEnd()
19083 
    if self.estimate is not None:
19084 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19085 
      oprot.writeI64(self.estimate)
19086 
      oprot.writeFieldEnd()
4369 rajveer 19087 
    if self.isReminder is not None:
19088 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19089 
      oprot.writeBool(self.isReminder)
19090 
      oprot.writeFieldEnd()
4303 rajveer 19091 
    oprot.writeFieldStop()
19092 
    oprot.writeStructEnd()
19093 
 
19094 
  def validate(self):
19095 
    return
19096 
 
19097 
 
19098 
  def __repr__(self):
19099 
    L = ['%s=%r' % (key, value)
19100 
      for key, value in self.__dict__.iteritems()]
19101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19102 
 
19103 
  def __eq__(self, other):
19104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19105 
 
19106 
  def __ne__(self, other):
19107 
    return not (self == other)
19108 
 
19109 
class markOrdersAsPORaised_result:
19110 
  """
19111 
  Attributes:
19112 
   - ex
19113 
  """
19114 
 
19115 
  thrift_spec = (
19116 
    None, # 0
19117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19118 
  )
19119 
 
19120 
  def __init__(self, ex=None,):
19121 
    self.ex = ex
19122 
 
19123 
  def read(self, iprot):
19124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19126 
      return
19127 
    iprot.readStructBegin()
19128 
    while True:
19129 
      (fname, ftype, fid) = iprot.readFieldBegin()
19130 
      if ftype == TType.STOP:
19131 
        break
19132 
      if fid == 1:
19133 
        if ftype == TType.STRUCT:
19134 
          self.ex = TransactionServiceException()
19135 
          self.ex.read(iprot)
19136 
        else:
19137 
          iprot.skip(ftype)
19138 
      else:
19139 
        iprot.skip(ftype)
19140 
      iprot.readFieldEnd()
19141 
    iprot.readStructEnd()
19142 
 
19143 
  def write(self, oprot):
19144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19146 
      return
19147 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
19148 
    if self.ex is not None:
19149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19150 
      self.ex.write(oprot)
19151 
      oprot.writeFieldEnd()
19152 
    oprot.writeFieldStop()
19153 
    oprot.writeStructEnd()
19154 
 
19155 
  def validate(self):
19156 
    return
19157 
 
19158 
 
19159 
  def __repr__(self):
19160 
    L = ['%s=%r' % (key, value)
19161 
      for key, value in self.__dict__.iteritems()]
19162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19163 
 
19164 
  def __eq__(self, other):
19165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19166 
 
19167 
  def __ne__(self, other):
19168 
    return not (self == other)
19169 
 
19170 
class markOrdersAsReversalInitiated_args:
19171 
  """
19172 
  Attributes:
19173 
   - vendorId
19174 
   - itemId
19175 
   - quantity
19176 
   - estimate
4369 rajveer 19177 
   - isReminder
4303 rajveer 19178 
  """
19179 
 
19180 
  thrift_spec = (
19181 
    None, # 0
19182 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19183 
    (2, TType.I64, 'itemId', None, None, ), # 2
19184 
    (3, TType.I64, 'quantity', None, None, ), # 3
19185 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19186 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19187 
  )
19188 
 
4369 rajveer 19189 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19190 
    self.vendorId = vendorId
19191 
    self.itemId = itemId
19192 
    self.quantity = quantity
19193 
    self.estimate = estimate
4369 rajveer 19194 
    self.isReminder = isReminder
4303 rajveer 19195 
 
19196 
  def read(self, iprot):
19197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19199 
      return
19200 
    iprot.readStructBegin()
19201 
    while True:
19202 
      (fname, ftype, fid) = iprot.readFieldBegin()
19203 
      if ftype == TType.STOP:
19204 
        break
19205 
      if fid == 1:
19206 
        if ftype == TType.I64:
19207 
          self.vendorId = iprot.readI64();
19208 
        else:
19209 
          iprot.skip(ftype)
19210 
      elif fid == 2:
19211 
        if ftype == TType.I64:
19212 
          self.itemId = iprot.readI64();
19213 
        else:
19214 
          iprot.skip(ftype)
19215 
      elif fid == 3:
19216 
        if ftype == TType.I64:
19217 
          self.quantity = iprot.readI64();
19218 
        else:
19219 
          iprot.skip(ftype)
19220 
      elif fid == 4:
19221 
        if ftype == TType.I64:
19222 
          self.estimate = iprot.readI64();
19223 
        else:
19224 
          iprot.skip(ftype)
4369 rajveer 19225 
      elif fid == 5:
19226 
        if ftype == TType.BOOL:
19227 
          self.isReminder = iprot.readBool();
19228 
        else:
19229 
          iprot.skip(ftype)
4303 rajveer 19230 
      else:
19231 
        iprot.skip(ftype)
19232 
      iprot.readFieldEnd()
19233 
    iprot.readStructEnd()
19234 
 
19235 
  def write(self, oprot):
19236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19238 
      return
19239 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
19240 
    if self.vendorId is not None:
19241 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19242 
      oprot.writeI64(self.vendorId)
19243 
      oprot.writeFieldEnd()
19244 
    if self.itemId is not None:
19245 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19246 
      oprot.writeI64(self.itemId)
19247 
      oprot.writeFieldEnd()
19248 
    if self.quantity is not None:
19249 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19250 
      oprot.writeI64(self.quantity)
19251 
      oprot.writeFieldEnd()
19252 
    if self.estimate is not None:
19253 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19254 
      oprot.writeI64(self.estimate)
19255 
      oprot.writeFieldEnd()
4369 rajveer 19256 
    if self.isReminder is not None:
19257 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19258 
      oprot.writeBool(self.isReminder)
19259 
      oprot.writeFieldEnd()
4303 rajveer 19260 
    oprot.writeFieldStop()
19261 
    oprot.writeStructEnd()
19262 
 
19263 
  def validate(self):
19264 
    return
19265 
 
19266 
 
19267 
  def __repr__(self):
19268 
    L = ['%s=%r' % (key, value)
19269 
      for key, value in self.__dict__.iteritems()]
19270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19271 
 
19272 
  def __eq__(self, other):
19273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19274 
 
19275 
  def __ne__(self, other):
19276 
    return not (self == other)
19277 
 
19278 
class markOrdersAsReversalInitiated_result:
19279 
  """
19280 
  Attributes:
19281 
   - ex
19282 
  """
19283 
 
19284 
  thrift_spec = (
19285 
    None, # 0
19286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19287 
  )
19288 
 
19289 
  def __init__(self, ex=None,):
19290 
    self.ex = ex
19291 
 
19292 
  def read(self, iprot):
19293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19295 
      return
19296 
    iprot.readStructBegin()
19297 
    while True:
19298 
      (fname, ftype, fid) = iprot.readFieldBegin()
19299 
      if ftype == TType.STOP:
19300 
        break
19301 
      if fid == 1:
19302 
        if ftype == TType.STRUCT:
19303 
          self.ex = TransactionServiceException()
19304 
          self.ex.read(iprot)
19305 
        else:
19306 
          iprot.skip(ftype)
19307 
      else:
19308 
        iprot.skip(ftype)
19309 
      iprot.readFieldEnd()
19310 
    iprot.readStructEnd()
19311 
 
19312 
  def write(self, oprot):
19313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19315 
      return
19316 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
19317 
    if self.ex is not None:
19318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19319 
      self.ex.write(oprot)
19320 
      oprot.writeFieldEnd()
19321 
    oprot.writeFieldStop()
19322 
    oprot.writeStructEnd()
19323 
 
19324 
  def validate(self):
19325 
    return
19326 
 
19327 
 
19328 
  def __repr__(self):
19329 
    L = ['%s=%r' % (key, value)
19330 
      for key, value in self.__dict__.iteritems()]
19331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19332 
 
19333 
  def __eq__(self, other):
19334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19335 
 
19336 
  def __ne__(self, other):
19337 
    return not (self == other)
19338 
 
19339 
class markOrdersAsNotAvailabke_args:
19340 
  """
19341 
  Attributes:
19342 
   - vendorId
19343 
   - itemId
19344 
   - quantity
19345 
   - estimate
4369 rajveer 19346 
   - isReminder
4303 rajveer 19347 
  """
19348 
 
19349 
  thrift_spec = (
19350 
    None, # 0
19351 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19352 
    (2, TType.I64, 'itemId', None, None, ), # 2
19353 
    (3, TType.I64, 'quantity', None, None, ), # 3
19354 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19355 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19356 
  )
19357 
 
4369 rajveer 19358 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19359 
    self.vendorId = vendorId
19360 
    self.itemId = itemId
19361 
    self.quantity = quantity
19362 
    self.estimate = estimate
4369 rajveer 19363 
    self.isReminder = isReminder
4303 rajveer 19364 
 
19365 
  def read(self, iprot):
19366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19368 
      return
19369 
    iprot.readStructBegin()
19370 
    while True:
19371 
      (fname, ftype, fid) = iprot.readFieldBegin()
19372 
      if ftype == TType.STOP:
19373 
        break
19374 
      if fid == 1:
19375 
        if ftype == TType.I64:
19376 
          self.vendorId = iprot.readI64();
19377 
        else:
19378 
          iprot.skip(ftype)
19379 
      elif fid == 2:
19380 
        if ftype == TType.I64:
19381 
          self.itemId = iprot.readI64();
19382 
        else:
19383 
          iprot.skip(ftype)
19384 
      elif fid == 3:
19385 
        if ftype == TType.I64:
19386 
          self.quantity = iprot.readI64();
19387 
        else:
19388 
          iprot.skip(ftype)
19389 
      elif fid == 4:
19390 
        if ftype == TType.I64:
19391 
          self.estimate = iprot.readI64();
19392 
        else:
19393 
          iprot.skip(ftype)
4369 rajveer 19394 
      elif fid == 5:
19395 
        if ftype == TType.BOOL:
19396 
          self.isReminder = iprot.readBool();
19397 
        else:
19398 
          iprot.skip(ftype)
4303 rajveer 19399 
      else:
19400 
        iprot.skip(ftype)
19401 
      iprot.readFieldEnd()
19402 
    iprot.readStructEnd()
19403 
 
19404 
  def write(self, oprot):
19405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19407 
      return
19408 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19409 
    if self.vendorId is not None:
19410 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19411 
      oprot.writeI64(self.vendorId)
19412 
      oprot.writeFieldEnd()
19413 
    if self.itemId is not None:
19414 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19415 
      oprot.writeI64(self.itemId)
19416 
      oprot.writeFieldEnd()
19417 
    if self.quantity is not None:
19418 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19419 
      oprot.writeI64(self.quantity)
19420 
      oprot.writeFieldEnd()
19421 
    if self.estimate is not None:
19422 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19423 
      oprot.writeI64(self.estimate)
19424 
      oprot.writeFieldEnd()
4369 rajveer 19425 
    if self.isReminder is not None:
19426 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19427 
      oprot.writeBool(self.isReminder)
19428 
      oprot.writeFieldEnd()
4303 rajveer 19429 
    oprot.writeFieldStop()
19430 
    oprot.writeStructEnd()
19431 
 
19432 
  def validate(self):
19433 
    return
19434 
 
19435 
 
19436 
  def __repr__(self):
19437 
    L = ['%s=%r' % (key, value)
19438 
      for key, value in self.__dict__.iteritems()]
19439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19440 
 
19441 
  def __eq__(self, other):
19442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19443 
 
19444 
  def __ne__(self, other):
19445 
    return not (self == other)
19446 
 
19447 
class markOrdersAsNotAvailabke_result:
19448 
  """
19449 
  Attributes:
19450 
   - ex
19451 
  """
19452 
 
19453 
  thrift_spec = (
19454 
    None, # 0
19455 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19456 
  )
19457 
 
19458 
  def __init__(self, ex=None,):
19459 
    self.ex = ex
19460 
 
19461 
  def read(self, iprot):
19462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19464 
      return
19465 
    iprot.readStructBegin()
19466 
    while True:
19467 
      (fname, ftype, fid) = iprot.readFieldBegin()
19468 
      if ftype == TType.STOP:
19469 
        break
19470 
      if fid == 1:
19471 
        if ftype == TType.STRUCT:
19472 
          self.ex = TransactionServiceException()
19473 
          self.ex.read(iprot)
19474 
        else:
19475 
          iprot.skip(ftype)
19476 
      else:
19477 
        iprot.skip(ftype)
19478 
      iprot.readFieldEnd()
19479 
    iprot.readStructEnd()
19480 
 
19481 
  def write(self, oprot):
19482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19484 
      return
19485 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19486 
    if self.ex is not None:
19487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19488 
      self.ex.write(oprot)
19489 
      oprot.writeFieldEnd()
19490 
    oprot.writeFieldStop()
19491 
    oprot.writeStructEnd()
19492 
 
19493 
  def validate(self):
19494 
    return
19495 
 
19496 
 
19497 
  def __repr__(self):
19498 
    L = ['%s=%r' % (key, value)
19499 
      for key, value in self.__dict__.iteritems()]
19500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19501 
 
19502 
  def __eq__(self, other):
19503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19504 
 
19505 
  def __ne__(self, other):
19506 
    return not (self == other)
4369 rajveer 19507 
 
19508 
class markOrdersAsTimeout_args:
19509 
  """
19510 
  Attributes:
19511 
   - vendorId
19512 
  """
19513 
 
19514 
  thrift_spec = (
19515 
    None, # 0
19516 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19517 
  )
19518 
 
19519 
  def __init__(self, vendorId=None,):
19520 
    self.vendorId = vendorId
19521 
 
19522 
  def read(self, iprot):
19523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19525 
      return
19526 
    iprot.readStructBegin()
19527 
    while True:
19528 
      (fname, ftype, fid) = iprot.readFieldBegin()
19529 
      if ftype == TType.STOP:
19530 
        break
19531 
      if fid == 1:
19532 
        if ftype == TType.I64:
19533 
          self.vendorId = iprot.readI64();
19534 
        else:
19535 
          iprot.skip(ftype)
19536 
      else:
19537 
        iprot.skip(ftype)
19538 
      iprot.readFieldEnd()
19539 
    iprot.readStructEnd()
19540 
 
19541 
  def write(self, oprot):
19542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19544 
      return
19545 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19546 
    if self.vendorId is not None:
19547 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19548 
      oprot.writeI64(self.vendorId)
19549 
      oprot.writeFieldEnd()
19550 
    oprot.writeFieldStop()
19551 
    oprot.writeStructEnd()
19552 
 
19553 
  def validate(self):
19554 
    return
19555 
 
19556 
 
19557 
  def __repr__(self):
19558 
    L = ['%s=%r' % (key, value)
19559 
      for key, value in self.__dict__.iteritems()]
19560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19561 
 
19562 
  def __eq__(self, other):
19563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19564 
 
19565 
  def __ne__(self, other):
19566 
    return not (self == other)
19567 
 
19568 
class markOrdersAsTimeout_result:
19569 
  """
19570 
  Attributes:
19571 
   - success
19572 
   - ex
19573 
  """
19574 
 
19575 
  thrift_spec = (
19576 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19578 
  )
19579 
 
19580 
  def __init__(self, success=None, ex=None,):
19581 
    self.success = success
19582 
    self.ex = ex
19583 
 
19584 
  def read(self, iprot):
19585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19587 
      return
19588 
    iprot.readStructBegin()
19589 
    while True:
19590 
      (fname, ftype, fid) = iprot.readFieldBegin()
19591 
      if ftype == TType.STOP:
19592 
        break
19593 
      if fid == 0:
19594 
        if ftype == TType.MAP:
19595 
          self.success = {}
5411 rajveer 19596 
          (_ktype438, _vtype439, _size437 ) = iprot.readMapBegin()
19597 
          for _i441 in xrange(_size437):
19598 
            _key442 = iprot.readI32();
19599 
            _val443 = TimeoutSummary()
19600 
            _val443.read(iprot)
19601 
            self.success[_key442] = _val443
4369 rajveer 19602 
          iprot.readMapEnd()
19603 
        else:
19604 
          iprot.skip(ftype)
19605 
      elif fid == 1:
19606 
        if ftype == TType.STRUCT:
19607 
          self.ex = TransactionServiceException()
19608 
          self.ex.read(iprot)
19609 
        else:
19610 
          iprot.skip(ftype)
19611 
      else:
19612 
        iprot.skip(ftype)
19613 
      iprot.readFieldEnd()
19614 
    iprot.readStructEnd()
19615 
 
19616 
  def write(self, oprot):
19617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19619 
      return
19620 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19621 
    if self.success is not None:
19622 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19623 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5411 rajveer 19624 
      for kiter444,viter445 in self.success.items():
19625 
        oprot.writeI32(kiter444)
19626 
        viter445.write(oprot)
4369 rajveer 19627 
      oprot.writeMapEnd()
19628 
      oprot.writeFieldEnd()
19629 
    if self.ex is not None:
19630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19631 
      self.ex.write(oprot)
19632 
      oprot.writeFieldEnd()
19633 
    oprot.writeFieldStop()
19634 
    oprot.writeStructEnd()
19635 
 
19636 
  def validate(self):
19637 
    return
19638 
 
19639 
 
19640 
  def __repr__(self):
19641 
    L = ['%s=%r' % (key, value)
19642 
      for key, value in self.__dict__.iteritems()]
19643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19644 
 
19645 
  def __eq__(self, other):
19646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19647 
 
19648 
  def __ne__(self, other):
19649 
    return not (self == other)
4386 anupam.sin 19650 
 
4662 rajveer 19651 
class markOrderAsLostInTransit_args:
19652 
  """
19653 
  Attributes:
19654 
   - orderId
19655 
  """
19656 
 
19657 
  thrift_spec = (
19658 
    None, # 0
19659 
    (1, TType.I64, 'orderId', None, None, ), # 1
19660 
  )
19661 
 
19662 
  def __init__(self, orderId=None,):
19663 
    self.orderId = orderId
19664 
 
19665 
  def read(self, iprot):
19666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19668 
      return
19669 
    iprot.readStructBegin()
19670 
    while True:
19671 
      (fname, ftype, fid) = iprot.readFieldBegin()
19672 
      if ftype == TType.STOP:
19673 
        break
19674 
      if fid == 1:
19675 
        if ftype == TType.I64:
19676 
          self.orderId = iprot.readI64();
19677 
        else:
19678 
          iprot.skip(ftype)
19679 
      else:
19680 
        iprot.skip(ftype)
19681 
      iprot.readFieldEnd()
19682 
    iprot.readStructEnd()
19683 
 
19684 
  def write(self, oprot):
19685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19687 
      return
19688 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19689 
    if self.orderId is not None:
19690 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19691 
      oprot.writeI64(self.orderId)
19692 
      oprot.writeFieldEnd()
19693 
    oprot.writeFieldStop()
19694 
    oprot.writeStructEnd()
19695 
 
19696 
  def validate(self):
19697 
    return
19698 
 
19699 
 
19700 
  def __repr__(self):
19701 
    L = ['%s=%r' % (key, value)
19702 
      for key, value in self.__dict__.iteritems()]
19703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19704 
 
19705 
  def __eq__(self, other):
19706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19707 
 
19708 
  def __ne__(self, other):
19709 
    return not (self == other)
19710 
 
19711 
class markOrderAsLostInTransit_result:
19712 
  """
19713 
  Attributes:
19714 
   - success
19715 
   - ex
19716 
  """
19717 
 
19718 
  thrift_spec = (
19719 
    (0, TType.BOOL, 'success', None, None, ), # 0
19720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19721 
  )
19722 
 
19723 
  def __init__(self, success=None, ex=None,):
19724 
    self.success = success
19725 
    self.ex = ex
19726 
 
19727 
  def read(self, iprot):
19728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19730 
      return
19731 
    iprot.readStructBegin()
19732 
    while True:
19733 
      (fname, ftype, fid) = iprot.readFieldBegin()
19734 
      if ftype == TType.STOP:
19735 
        break
19736 
      if fid == 0:
19737 
        if ftype == TType.BOOL:
19738 
          self.success = iprot.readBool();
19739 
        else:
19740 
          iprot.skip(ftype)
19741 
      elif fid == 1:
19742 
        if ftype == TType.STRUCT:
19743 
          self.ex = TransactionServiceException()
19744 
          self.ex.read(iprot)
19745 
        else:
19746 
          iprot.skip(ftype)
19747 
      else:
19748 
        iprot.skip(ftype)
19749 
      iprot.readFieldEnd()
19750 
    iprot.readStructEnd()
19751 
 
19752 
  def write(self, oprot):
19753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19755 
      return
19756 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19757 
    if self.success is not None:
19758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19759 
      oprot.writeBool(self.success)
19760 
      oprot.writeFieldEnd()
19761 
    if self.ex is not None:
19762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19763 
      self.ex.write(oprot)
19764 
      oprot.writeFieldEnd()
19765 
    oprot.writeFieldStop()
19766 
    oprot.writeStructEnd()
19767 
 
19768 
  def validate(self):
19769 
    return
19770 
 
19771 
 
19772 
  def __repr__(self):
19773 
    L = ['%s=%r' % (key, value)
19774 
      for key, value in self.__dict__.iteritems()]
19775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19776 
 
19777 
  def __eq__(self, other):
19778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19779 
 
19780 
  def __ne__(self, other):
19781 
    return not (self == other)
19782 
 
4386 anupam.sin 19783 
class getOrderForAwb_args:
19784 
  """
19785 
  Attributes:
19786 
   - awb
19787 
  """
19788 
 
19789 
  thrift_spec = (
19790 
    None, # 0
19791 
    (1, TType.STRING, 'awb', None, None, ), # 1
19792 
  )
19793 
 
19794 
  def __init__(self, awb=None,):
19795 
    self.awb = awb
19796 
 
19797 
  def read(self, iprot):
19798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19800 
      return
19801 
    iprot.readStructBegin()
19802 
    while True:
19803 
      (fname, ftype, fid) = iprot.readFieldBegin()
19804 
      if ftype == TType.STOP:
19805 
        break
19806 
      if fid == 1:
19807 
        if ftype == TType.STRING:
19808 
          self.awb = iprot.readString();
19809 
        else:
19810 
          iprot.skip(ftype)
19811 
      else:
19812 
        iprot.skip(ftype)
19813 
      iprot.readFieldEnd()
19814 
    iprot.readStructEnd()
19815 
 
19816 
  def write(self, oprot):
19817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19819 
      return
19820 
    oprot.writeStructBegin('getOrderForAwb_args')
19821 
    if self.awb is not None:
19822 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19823 
      oprot.writeString(self.awb)
19824 
      oprot.writeFieldEnd()
19825 
    oprot.writeFieldStop()
19826 
    oprot.writeStructEnd()
19827 
 
19828 
  def validate(self):
19829 
    return
19830 
 
19831 
 
19832 
  def __repr__(self):
19833 
    L = ['%s=%r' % (key, value)
19834 
      for key, value in self.__dict__.iteritems()]
19835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19836 
 
19837 
  def __eq__(self, other):
19838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19839 
 
19840 
  def __ne__(self, other):
19841 
    return not (self == other)
19842 
 
19843 
class getOrderForAwb_result:
19844 
  """
19845 
  Attributes:
19846 
   - success
19847 
   - ex
19848 
  """
19849 
 
19850 
  thrift_spec = (
19851 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19853 
  )
19854 
 
19855 
  def __init__(self, success=None, ex=None,):
19856 
    self.success = success
19857 
    self.ex = ex
19858 
 
19859 
  def read(self, iprot):
19860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19862 
      return
19863 
    iprot.readStructBegin()
19864 
    while True:
19865 
      (fname, ftype, fid) = iprot.readFieldBegin()
19866 
      if ftype == TType.STOP:
19867 
        break
19868 
      if fid == 0:
19869 
        if ftype == TType.STRUCT:
19870 
          self.success = Order()
19871 
          self.success.read(iprot)
19872 
        else:
19873 
          iprot.skip(ftype)
19874 
      elif fid == 1:
19875 
        if ftype == TType.STRUCT:
19876 
          self.ex = TransactionServiceException()
19877 
          self.ex.read(iprot)
19878 
        else:
19879 
          iprot.skip(ftype)
19880 
      else:
19881 
        iprot.skip(ftype)
19882 
      iprot.readFieldEnd()
19883 
    iprot.readStructEnd()
19884 
 
19885 
  def write(self, oprot):
19886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19888 
      return
19889 
    oprot.writeStructBegin('getOrderForAwb_result')
19890 
    if self.success is not None:
19891 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19892 
      self.success.write(oprot)
19893 
      oprot.writeFieldEnd()
19894 
    if self.ex is not None:
19895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19896 
      self.ex.write(oprot)
19897 
      oprot.writeFieldEnd()
19898 
    oprot.writeFieldStop()
19899 
    oprot.writeStructEnd()
19900 
 
19901 
  def validate(self):
19902 
    return
19903 
 
19904 
 
19905 
  def __repr__(self):
19906 
    L = ['%s=%r' % (key, value)
19907 
      for key, value in self.__dict__.iteritems()]
19908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19909 
 
19910 
  def __eq__(self, other):
19911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19912 
 
19913 
  def __ne__(self, other):
19914 
    return not (self == other)
4506 phani.kuma 19915 
 
19916 
class getOrdersForProviderForStatus_args:
19917 
  """
19918 
  Attributes:
19919 
   - logistics_provider_id
4910 phani.kuma 19920 
   - order_status_list
4506 phani.kuma 19921 
  """
19922 
 
19923 
  thrift_spec = (
19924 
    None, # 0
19925 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19926 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19927 
  )
19928 
 
4910 phani.kuma 19929 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19930 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19931 
    self.order_status_list = order_status_list
4506 phani.kuma 19932 
 
19933 
  def read(self, iprot):
19934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19936 
      return
19937 
    iprot.readStructBegin()
19938 
    while True:
19939 
      (fname, ftype, fid) = iprot.readFieldBegin()
19940 
      if ftype == TType.STOP:
19941 
        break
19942 
      if fid == 1:
19943 
        if ftype == TType.I64:
19944 
          self.logistics_provider_id = iprot.readI64();
19945 
        else:
19946 
          iprot.skip(ftype)
19947 
      elif fid == 2:
4910 phani.kuma 19948 
        if ftype == TType.LIST:
19949 
          self.order_status_list = []
5411 rajveer 19950 
          (_etype449, _size446) = iprot.readListBegin()
19951 
          for _i450 in xrange(_size446):
19952 
            _elem451 = iprot.readI32();
19953 
            self.order_status_list.append(_elem451)
4910 phani.kuma 19954 
          iprot.readListEnd()
4506 phani.kuma 19955 
        else:
19956 
          iprot.skip(ftype)
19957 
      else:
19958 
        iprot.skip(ftype)
19959 
      iprot.readFieldEnd()
19960 
    iprot.readStructEnd()
19961 
 
19962 
  def write(self, oprot):
19963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19965 
      return
19966 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19967 
    if self.logistics_provider_id is not None:
19968 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19969 
      oprot.writeI64(self.logistics_provider_id)
19970 
      oprot.writeFieldEnd()
4910 phani.kuma 19971 
    if self.order_status_list is not None:
19972 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19973 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5411 rajveer 19974 
      for iter452 in self.order_status_list:
19975 
        oprot.writeI32(iter452)
4910 phani.kuma 19976 
      oprot.writeListEnd()
4506 phani.kuma 19977 
      oprot.writeFieldEnd()
19978 
    oprot.writeFieldStop()
19979 
    oprot.writeStructEnd()
19980 
 
19981 
  def validate(self):
19982 
    return
19983 
 
19984 
 
19985 
  def __repr__(self):
19986 
    L = ['%s=%r' % (key, value)
19987 
      for key, value in self.__dict__.iteritems()]
19988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19989 
 
19990 
  def __eq__(self, other):
19991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19992 
 
19993 
  def __ne__(self, other):
19994 
    return not (self == other)
19995 
 
19996 
class getOrdersForProviderForStatus_result:
19997 
  """
19998 
  Attributes:
19999 
   - success
20000 
   - ex
20001 
  """
20002 
 
20003 
  thrift_spec = (
20004 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20006 
  )
20007 
 
20008 
  def __init__(self, success=None, ex=None,):
20009 
    self.success = success
20010 
    self.ex = ex
20011 
 
20012 
  def read(self, iprot):
20013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20015 
      return
20016 
    iprot.readStructBegin()
20017 
    while True:
20018 
      (fname, ftype, fid) = iprot.readFieldBegin()
20019 
      if ftype == TType.STOP:
20020 
        break
20021 
      if fid == 0:
20022 
        if ftype == TType.LIST:
20023 
          self.success = []
5411 rajveer 20024 
          (_etype456, _size453) = iprot.readListBegin()
20025 
          for _i457 in xrange(_size453):
20026 
            _elem458 = Order()
20027 
            _elem458.read(iprot)
20028 
            self.success.append(_elem458)
4506 phani.kuma 20029 
          iprot.readListEnd()
20030 
        else:
20031 
          iprot.skip(ftype)
20032 
      elif fid == 1:
20033 
        if ftype == TType.STRUCT:
20034 
          self.ex = TransactionServiceException()
20035 
          self.ex.read(iprot)
20036 
        else:
20037 
          iprot.skip(ftype)
20038 
      else:
20039 
        iprot.skip(ftype)
20040 
      iprot.readFieldEnd()
20041 
    iprot.readStructEnd()
20042 
 
20043 
  def write(self, oprot):
20044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20046 
      return
20047 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
20048 
    if self.success is not None:
20049 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20050 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20051 
      for iter459 in self.success:
20052 
        iter459.write(oprot)
4506 phani.kuma 20053 
      oprot.writeListEnd()
20054 
      oprot.writeFieldEnd()
20055 
    if self.ex is not None:
20056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20057 
      self.ex.write(oprot)
20058 
      oprot.writeFieldEnd()
20059 
    oprot.writeFieldStop()
20060 
    oprot.writeStructEnd()
20061 
 
20062 
  def validate(self):
20063 
    return
20064 
 
20065 
 
20066 
  def __repr__(self):
20067 
    L = ['%s=%r' % (key, value)
20068 
      for key, value in self.__dict__.iteritems()]
20069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20070 
 
20071 
  def __eq__(self, other):
20072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20073 
 
20074 
  def __ne__(self, other):
20075 
    return not (self == other)
4600 varun.gupt 20076 
 
20077 
class getBilledOrdersForVendor_args:
20078 
  """
20079 
  Attributes:
20080 
   - vendorId
20081 
   - billingDateFrom
20082 
   - billingDateTo
20083 
  """
20084 
 
20085 
  thrift_spec = (
20086 
    None, # 0
20087 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20088 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
20089 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
20090 
  )
20091 
 
20092 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
20093 
    self.vendorId = vendorId
20094 
    self.billingDateFrom = billingDateFrom
20095 
    self.billingDateTo = billingDateTo
20096 
 
20097 
  def read(self, iprot):
20098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20100 
      return
20101 
    iprot.readStructBegin()
20102 
    while True:
20103 
      (fname, ftype, fid) = iprot.readFieldBegin()
20104 
      if ftype == TType.STOP:
20105 
        break
20106 
      if fid == 1:
20107 
        if ftype == TType.I64:
20108 
          self.vendorId = iprot.readI64();
20109 
        else:
20110 
          iprot.skip(ftype)
20111 
      elif fid == 2:
20112 
        if ftype == TType.I64:
20113 
          self.billingDateFrom = iprot.readI64();
20114 
        else:
20115 
          iprot.skip(ftype)
20116 
      elif fid == 3:
20117 
        if ftype == TType.I64:
20118 
          self.billingDateTo = iprot.readI64();
20119 
        else:
20120 
          iprot.skip(ftype)
20121 
      else:
20122 
        iprot.skip(ftype)
20123 
      iprot.readFieldEnd()
20124 
    iprot.readStructEnd()
20125 
 
20126 
  def write(self, oprot):
20127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20129 
      return
20130 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
20131 
    if self.vendorId is not None:
20132 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20133 
      oprot.writeI64(self.vendorId)
20134 
      oprot.writeFieldEnd()
20135 
    if self.billingDateFrom is not None:
20136 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
20137 
      oprot.writeI64(self.billingDateFrom)
20138 
      oprot.writeFieldEnd()
20139 
    if self.billingDateTo is not None:
20140 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
20141 
      oprot.writeI64(self.billingDateTo)
20142 
      oprot.writeFieldEnd()
20143 
    oprot.writeFieldStop()
20144 
    oprot.writeStructEnd()
20145 
 
20146 
  def validate(self):
20147 
    return
20148 
 
20149 
 
20150 
  def __repr__(self):
20151 
    L = ['%s=%r' % (key, value)
20152 
      for key, value in self.__dict__.iteritems()]
20153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20154 
 
20155 
  def __eq__(self, other):
20156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20157 
 
20158 
  def __ne__(self, other):
20159 
    return not (self == other)
20160 
 
20161 
class getBilledOrdersForVendor_result:
20162 
  """
20163 
  Attributes:
20164 
   - success
20165 
   - ex
20166 
  """
20167 
 
20168 
  thrift_spec = (
20169 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20171 
  )
20172 
 
20173 
  def __init__(self, success=None, ex=None,):
20174 
    self.success = success
20175 
    self.ex = ex
20176 
 
20177 
  def read(self, iprot):
20178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20180 
      return
20181 
    iprot.readStructBegin()
20182 
    while True:
20183 
      (fname, ftype, fid) = iprot.readFieldBegin()
20184 
      if ftype == TType.STOP:
20185 
        break
20186 
      if fid == 0:
20187 
        if ftype == TType.LIST:
20188 
          self.success = []
5411 rajveer 20189 
          (_etype463, _size460) = iprot.readListBegin()
20190 
          for _i464 in xrange(_size460):
20191 
            _elem465 = Order()
20192 
            _elem465.read(iprot)
20193 
            self.success.append(_elem465)
4600 varun.gupt 20194 
          iprot.readListEnd()
20195 
        else:
20196 
          iprot.skip(ftype)
20197 
      elif fid == 1:
20198 
        if ftype == TType.STRUCT:
20199 
          self.ex = TransactionServiceException()
20200 
          self.ex.read(iprot)
20201 
        else:
20202 
          iprot.skip(ftype)
20203 
      else:
20204 
        iprot.skip(ftype)
20205 
      iprot.readFieldEnd()
20206 
    iprot.readStructEnd()
20207 
 
20208 
  def write(self, oprot):
20209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20211 
      return
20212 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
20213 
    if self.success is not None:
20214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20216 
      for iter466 in self.success:
20217 
        iter466.write(oprot)
4600 varun.gupt 20218 
      oprot.writeListEnd()
20219 
      oprot.writeFieldEnd()
20220 
    if self.ex is not None:
20221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20222 
      self.ex.write(oprot)
20223 
      oprot.writeFieldEnd()
20224 
    oprot.writeFieldStop()
20225 
    oprot.writeStructEnd()
20226 
 
20227 
  def validate(self):
20228 
    return
20229 
 
20230 
 
20231 
  def __repr__(self):
20232 
    L = ['%s=%r' % (key, value)
20233 
      for key, value in self.__dict__.iteritems()]
20234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20235 
 
20236 
  def __eq__(self, other):
20237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20238 
 
20239 
  def __ne__(self, other):
20240 
    return not (self == other)
20241 
 
4607 rajveer 20242 
class getSlippedSippingDateOrders_args:
20243 
 
20244 
  thrift_spec = (
20245 
  )
20246 
 
20247 
  def read(self, iprot):
20248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20250 
      return
20251 
    iprot.readStructBegin()
20252 
    while True:
20253 
      (fname, ftype, fid) = iprot.readFieldBegin()
20254 
      if ftype == TType.STOP:
20255 
        break
20256 
      else:
20257 
        iprot.skip(ftype)
20258 
      iprot.readFieldEnd()
20259 
    iprot.readStructEnd()
20260 
 
20261 
  def write(self, oprot):
20262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20264 
      return
20265 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
20266 
    oprot.writeFieldStop()
20267 
    oprot.writeStructEnd()
20268 
 
20269 
  def validate(self):
20270 
    return
20271 
 
20272 
 
20273 
  def __repr__(self):
20274 
    L = ['%s=%r' % (key, value)
20275 
      for key, value in self.__dict__.iteritems()]
20276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20277 
 
20278 
  def __eq__(self, other):
20279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20280 
 
20281 
  def __ne__(self, other):
20282 
    return not (self == other)
20283 
 
20284 
class getSlippedSippingDateOrders_result:
20285 
  """
20286 
  Attributes:
20287 
   - success
20288 
   - ex
20289 
  """
20290 
 
20291 
  thrift_spec = (
20292 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20294 
  )
20295 
 
20296 
  def __init__(self, success=None, ex=None,):
20297 
    self.success = success
20298 
    self.ex = ex
20299 
 
20300 
  def read(self, iprot):
20301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20303 
      return
20304 
    iprot.readStructBegin()
20305 
    while True:
20306 
      (fname, ftype, fid) = iprot.readFieldBegin()
20307 
      if ftype == TType.STOP:
20308 
        break
20309 
      if fid == 0:
20310 
        if ftype == TType.LIST:
20311 
          self.success = []
5411 rajveer 20312 
          (_etype470, _size467) = iprot.readListBegin()
20313 
          for _i471 in xrange(_size467):
20314 
            _elem472 = Order()
20315 
            _elem472.read(iprot)
20316 
            self.success.append(_elem472)
4607 rajveer 20317 
          iprot.readListEnd()
20318 
        else:
20319 
          iprot.skip(ftype)
20320 
      elif fid == 1:
20321 
        if ftype == TType.STRUCT:
20322 
          self.ex = TransactionServiceException()
20323 
          self.ex.read(iprot)
20324 
        else:
20325 
          iprot.skip(ftype)
20326 
      else:
20327 
        iprot.skip(ftype)
20328 
      iprot.readFieldEnd()
20329 
    iprot.readStructEnd()
20330 
 
20331 
  def write(self, oprot):
20332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20334 
      return
20335 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20336 
    if self.success is not None:
20337 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20338 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20339 
      for iter473 in self.success:
20340 
        iter473.write(oprot)
4607 rajveer 20341 
      oprot.writeListEnd()
20342 
      oprot.writeFieldEnd()
20343 
    if self.ex is not None:
20344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20345 
      self.ex.write(oprot)
20346 
      oprot.writeFieldEnd()
20347 
    oprot.writeFieldStop()
20348 
    oprot.writeStructEnd()
20349 
 
20350 
  def validate(self):
20351 
    return
20352 
 
20353 
 
20354 
  def __repr__(self):
20355 
    L = ['%s=%r' % (key, value)
20356 
      for key, value in self.__dict__.iteritems()]
20357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20358 
 
20359 
  def __eq__(self, other):
20360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20361 
 
20362 
  def __ne__(self, other):
20363 
    return not (self == other)
20364 
 
4709 rajveer 20365 
class getCancelledOrders_args:
20366 
  """
20367 
  Attributes:
20368 
   - cancelDateFrom
20369 
   - cancelDateTo
20370 
  """
20371 
 
20372 
  thrift_spec = (
20373 
    None, # 0
20374 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20375 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20376 
  )
20377 
 
20378 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20379 
    self.cancelDateFrom = cancelDateFrom
20380 
    self.cancelDateTo = cancelDateTo
20381 
 
20382 
  def read(self, iprot):
20383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20385 
      return
20386 
    iprot.readStructBegin()
20387 
    while True:
20388 
      (fname, ftype, fid) = iprot.readFieldBegin()
20389 
      if ftype == TType.STOP:
20390 
        break
20391 
      if fid == 1:
20392 
        if ftype == TType.I64:
20393 
          self.cancelDateFrom = iprot.readI64();
20394 
        else:
20395 
          iprot.skip(ftype)
20396 
      elif fid == 2:
20397 
        if ftype == TType.I64:
20398 
          self.cancelDateTo = iprot.readI64();
20399 
        else:
20400 
          iprot.skip(ftype)
20401 
      else:
20402 
        iprot.skip(ftype)
20403 
      iprot.readFieldEnd()
20404 
    iprot.readStructEnd()
20405 
 
20406 
  def write(self, oprot):
20407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20409 
      return
20410 
    oprot.writeStructBegin('getCancelledOrders_args')
20411 
    if self.cancelDateFrom is not None:
20412 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20413 
      oprot.writeI64(self.cancelDateFrom)
20414 
      oprot.writeFieldEnd()
20415 
    if self.cancelDateTo is not None:
20416 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20417 
      oprot.writeI64(self.cancelDateTo)
20418 
      oprot.writeFieldEnd()
20419 
    oprot.writeFieldStop()
20420 
    oprot.writeStructEnd()
20421 
 
20422 
  def validate(self):
20423 
    return
20424 
 
20425 
 
20426 
  def __repr__(self):
20427 
    L = ['%s=%r' % (key, value)
20428 
      for key, value in self.__dict__.iteritems()]
20429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20430 
 
20431 
  def __eq__(self, other):
20432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20433 
 
20434 
  def __ne__(self, other):
20435 
    return not (self == other)
20436 
 
20437 
class getCancelledOrders_result:
20438 
  """
20439 
  Attributes:
20440 
   - success
20441 
   - ex
20442 
  """
20443 
 
20444 
  thrift_spec = (
20445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20447 
  )
20448 
 
20449 
  def __init__(self, success=None, ex=None,):
20450 
    self.success = success
20451 
    self.ex = ex
20452 
 
20453 
  def read(self, iprot):
20454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20456 
      return
20457 
    iprot.readStructBegin()
20458 
    while True:
20459 
      (fname, ftype, fid) = iprot.readFieldBegin()
20460 
      if ftype == TType.STOP:
20461 
        break
20462 
      if fid == 0:
20463 
        if ftype == TType.LIST:
20464 
          self.success = []
5411 rajveer 20465 
          (_etype477, _size474) = iprot.readListBegin()
20466 
          for _i478 in xrange(_size474):
20467 
            _elem479 = Order()
20468 
            _elem479.read(iprot)
20469 
            self.success.append(_elem479)
4709 rajveer 20470 
          iprot.readListEnd()
20471 
        else:
20472 
          iprot.skip(ftype)
20473 
      elif fid == 1:
20474 
        if ftype == TType.STRUCT:
20475 
          self.ex = TransactionServiceException()
20476 
          self.ex.read(iprot)
20477 
        else:
20478 
          iprot.skip(ftype)
20479 
      else:
20480 
        iprot.skip(ftype)
20481 
      iprot.readFieldEnd()
20482 
    iprot.readStructEnd()
20483 
 
20484 
  def write(self, oprot):
20485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20487 
      return
20488 
    oprot.writeStructBegin('getCancelledOrders_result')
20489 
    if self.success is not None:
20490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20491 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 20492 
      for iter480 in self.success:
20493 
        iter480.write(oprot)
4709 rajveer 20494 
      oprot.writeListEnd()
20495 
      oprot.writeFieldEnd()
20496 
    if self.ex is not None:
20497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20498 
      self.ex.write(oprot)
20499 
      oprot.writeFieldEnd()
20500 
    oprot.writeFieldStop()
20501 
    oprot.writeStructEnd()
20502 
 
20503 
  def validate(self):
20504 
    return
20505 
 
20506 
 
20507 
  def __repr__(self):
20508 
    L = ['%s=%r' % (key, value)
20509 
      for key, value in self.__dict__.iteritems()]
20510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20511 
 
20512 
  def __eq__(self, other):
20513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20514 
 
20515 
  def __ne__(self, other):
20516 
    return not (self == other)
20517 
 
4600 varun.gupt 20518 
class saveBluedartSettlements_args:
20519 
  """
20520 
  Attributes:
20521 
   - mapAWBAndAmount
20522 
  """
20523 
 
20524 
  thrift_spec = (
20525 
    None, # 0
20526 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20527 
  )
20528 
 
20529 
  def __init__(self, mapAWBAndAmount=None,):
20530 
    self.mapAWBAndAmount = mapAWBAndAmount
20531 
 
20532 
  def read(self, iprot):
20533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20535 
      return
20536 
    iprot.readStructBegin()
20537 
    while True:
20538 
      (fname, ftype, fid) = iprot.readFieldBegin()
20539 
      if ftype == TType.STOP:
20540 
        break
20541 
      if fid == 1:
20542 
        if ftype == TType.MAP:
20543 
          self.mapAWBAndAmount = {}
5411 rajveer 20544 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
20545 
          for _i485 in xrange(_size481):
20546 
            _key486 = iprot.readI64();
20547 
            _val487 = iprot.readDouble();
20548 
            self.mapAWBAndAmount[_key486] = _val487
4600 varun.gupt 20549 
          iprot.readMapEnd()
20550 
        else:
20551 
          iprot.skip(ftype)
20552 
      else:
20553 
        iprot.skip(ftype)
20554 
      iprot.readFieldEnd()
20555 
    iprot.readStructEnd()
20556 
 
20557 
  def write(self, oprot):
20558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20560 
      return
20561 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20562 
    if self.mapAWBAndAmount is not None:
20563 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20564 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5411 rajveer 20565 
      for kiter488,viter489 in self.mapAWBAndAmount.items():
20566 
        oprot.writeI64(kiter488)
20567 
        oprot.writeDouble(viter489)
4600 varun.gupt 20568 
      oprot.writeMapEnd()
20569 
      oprot.writeFieldEnd()
20570 
    oprot.writeFieldStop()
20571 
    oprot.writeStructEnd()
20572 
 
20573 
  def validate(self):
20574 
    return
20575 
 
20576 
 
20577 
  def __repr__(self):
20578 
    L = ['%s=%r' % (key, value)
20579 
      for key, value in self.__dict__.iteritems()]
20580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20581 
 
20582 
  def __eq__(self, other):
20583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20584 
 
20585 
  def __ne__(self, other):
20586 
    return not (self == other)
20587 
 
20588 
class saveBluedartSettlements_result:
20589 
  """
20590 
  Attributes:
20591 
   - ex
20592 
  """
20593 
 
20594 
  thrift_spec = (
20595 
    None, # 0
20596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20597 
  )
20598 
 
20599 
  def __init__(self, ex=None,):
20600 
    self.ex = ex
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.STRUCT:
20613 
          self.ex = TransactionServiceException()
20614 
          self.ex.read(iprot)
20615 
        else:
20616 
          iprot.skip(ftype)
20617 
      else:
20618 
        iprot.skip(ftype)
20619 
      iprot.readFieldEnd()
20620 
    iprot.readStructEnd()
20621 
 
20622 
  def write(self, oprot):
20623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20625 
      return
20626 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20627 
    if self.ex is not None:
20628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20629 
      self.ex.write(oprot)
20630 
      oprot.writeFieldEnd()
20631 
    oprot.writeFieldStop()
20632 
    oprot.writeStructEnd()
20633 
 
20634 
  def validate(self):
20635 
    return
20636 
 
20637 
 
20638 
  def __repr__(self):
20639 
    L = ['%s=%r' % (key, value)
20640 
      for key, value in self.__dict__.iteritems()]
20641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20642 
 
20643 
  def __eq__(self, other):
20644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20645 
 
20646 
  def __ne__(self, other):
20647 
    return not (self == other)
20648 
 
20649 
class savePaymentSettlements_args:
20650 
  """
20651 
  Attributes:
20652 
   - settlementDate
20653 
   - paymentGatewayId
4905 varun.gupt 20654 
   - referenceId
4600 varun.gupt 20655 
   - serviceTax
20656 
   - otherCharges
20657 
   - netCollection
20658 
  """
20659 
 
20660 
  thrift_spec = (
20661 
    None, # 0
20662 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20663 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20664 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20665 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20666 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20667 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20668 
  )
20669 
 
4905 varun.gupt 20670 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20671 
    self.settlementDate = settlementDate
20672 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20673 
    self.referenceId = referenceId
4600 varun.gupt 20674 
    self.serviceTax = serviceTax
20675 
    self.otherCharges = otherCharges
20676 
    self.netCollection = netCollection
20677 
 
20678 
  def read(self, iprot):
20679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20681 
      return
20682 
    iprot.readStructBegin()
20683 
    while True:
20684 
      (fname, ftype, fid) = iprot.readFieldBegin()
20685 
      if ftype == TType.STOP:
20686 
        break
20687 
      if fid == 1:
20688 
        if ftype == TType.I64:
20689 
          self.settlementDate = iprot.readI64();
20690 
        else:
20691 
          iprot.skip(ftype)
20692 
      elif fid == 2:
20693 
        if ftype == TType.I64:
20694 
          self.paymentGatewayId = iprot.readI64();
20695 
        else:
20696 
          iprot.skip(ftype)
20697 
      elif fid == 3:
20698 
        if ftype == TType.I64:
4905 varun.gupt 20699 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20700 
        else:
20701 
          iprot.skip(ftype)
20702 
      elif fid == 4:
20703 
        if ftype == TType.DOUBLE:
20704 
          self.serviceTax = iprot.readDouble();
20705 
        else:
20706 
          iprot.skip(ftype)
20707 
      elif fid == 5:
20708 
        if ftype == TType.DOUBLE:
20709 
          self.otherCharges = iprot.readDouble();
20710 
        else:
20711 
          iprot.skip(ftype)
20712 
      elif fid == 6:
20713 
        if ftype == TType.DOUBLE:
20714 
          self.netCollection = iprot.readDouble();
20715 
        else:
20716 
          iprot.skip(ftype)
20717 
      else:
20718 
        iprot.skip(ftype)
20719 
      iprot.readFieldEnd()
20720 
    iprot.readStructEnd()
20721 
 
20722 
  def write(self, oprot):
20723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20725 
      return
20726 
    oprot.writeStructBegin('savePaymentSettlements_args')
20727 
    if self.settlementDate is not None:
20728 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20729 
      oprot.writeI64(self.settlementDate)
20730 
      oprot.writeFieldEnd()
20731 
    if self.paymentGatewayId is not None:
20732 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20733 
      oprot.writeI64(self.paymentGatewayId)
20734 
      oprot.writeFieldEnd()
4905 varun.gupt 20735 
    if self.referenceId is not None:
20736 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20737 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20738 
      oprot.writeFieldEnd()
20739 
    if self.serviceTax is not None:
20740 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20741 
      oprot.writeDouble(self.serviceTax)
20742 
      oprot.writeFieldEnd()
20743 
    if self.otherCharges is not None:
20744 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20745 
      oprot.writeDouble(self.otherCharges)
20746 
      oprot.writeFieldEnd()
20747 
    if self.netCollection is not None:
20748 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20749 
      oprot.writeDouble(self.netCollection)
20750 
      oprot.writeFieldEnd()
20751 
    oprot.writeFieldStop()
20752 
    oprot.writeStructEnd()
20753 
 
20754 
  def validate(self):
20755 
    return
20756 
 
20757 
 
20758 
  def __repr__(self):
20759 
    L = ['%s=%r' % (key, value)
20760 
      for key, value in self.__dict__.iteritems()]
20761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20762 
 
20763 
  def __eq__(self, other):
20764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20765 
 
20766 
  def __ne__(self, other):
20767 
    return not (self == other)
20768 
 
20769 
class savePaymentSettlements_result:
20770 
  """
20771 
  Attributes:
20772 
   - ex
20773 
  """
20774 
 
20775 
  thrift_spec = (
20776 
    None, # 0
20777 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20778 
  )
20779 
 
20780 
  def __init__(self, ex=None,):
20781 
    self.ex = ex
20782 
 
20783 
  def read(self, iprot):
20784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20786 
      return
20787 
    iprot.readStructBegin()
20788 
    while True:
20789 
      (fname, ftype, fid) = iprot.readFieldBegin()
20790 
      if ftype == TType.STOP:
20791 
        break
20792 
      if fid == 1:
20793 
        if ftype == TType.STRUCT:
20794 
          self.ex = TransactionServiceException()
20795 
          self.ex.read(iprot)
20796 
        else:
20797 
          iprot.skip(ftype)
20798 
      else:
20799 
        iprot.skip(ftype)
20800 
      iprot.readFieldEnd()
20801 
    iprot.readStructEnd()
20802 
 
20803 
  def write(self, oprot):
20804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20806 
      return
20807 
    oprot.writeStructBegin('savePaymentSettlements_result')
20808 
    if self.ex is not None:
20809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20810 
      self.ex.write(oprot)
20811 
      oprot.writeFieldEnd()
20812 
    oprot.writeFieldStop()
20813 
    oprot.writeStructEnd()
20814 
 
20815 
  def validate(self):
20816 
    return
20817 
 
20818 
 
20819 
  def __repr__(self):
20820 
    L = ['%s=%r' % (key, value)
20821 
      for key, value in self.__dict__.iteritems()]
20822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20823 
 
20824 
  def __eq__(self, other):
20825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20826 
 
20827 
  def __ne__(self, other):
20828 
    return not (self == other)
20829 
 
20830 
class saveEBSSettlementSummary_args:
20831 
  """
20832 
  Attributes:
20833 
   - settlementId
20834 
   - settlementDate
20835 
   - transactionDateFrom
20836 
   - transactionDateTo
20837 
   - amount
20838 
  """
20839 
 
20840 
  thrift_spec = (
20841 
    None, # 0
20842 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20843 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20844 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20845 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20846 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20847 
  )
20848 
 
20849 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20850 
    self.settlementId = settlementId
20851 
    self.settlementDate = settlementDate
20852 
    self.transactionDateFrom = transactionDateFrom
20853 
    self.transactionDateTo = transactionDateTo
20854 
    self.amount = amount
20855 
 
20856 
  def read(self, iprot):
20857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20859 
      return
20860 
    iprot.readStructBegin()
20861 
    while True:
20862 
      (fname, ftype, fid) = iprot.readFieldBegin()
20863 
      if ftype == TType.STOP:
20864 
        break
20865 
      if fid == 1:
20866 
        if ftype == TType.I64:
20867 
          self.settlementId = iprot.readI64();
20868 
        else:
20869 
          iprot.skip(ftype)
20870 
      elif fid == 2:
20871 
        if ftype == TType.I64:
20872 
          self.settlementDate = iprot.readI64();
20873 
        else:
20874 
          iprot.skip(ftype)
20875 
      elif fid == 3:
20876 
        if ftype == TType.I64:
20877 
          self.transactionDateFrom = iprot.readI64();
20878 
        else:
20879 
          iprot.skip(ftype)
20880 
      elif fid == 4:
20881 
        if ftype == TType.I64:
20882 
          self.transactionDateTo = iprot.readI64();
20883 
        else:
20884 
          iprot.skip(ftype)
20885 
      elif fid == 5:
20886 
        if ftype == TType.DOUBLE:
20887 
          self.amount = iprot.readDouble();
20888 
        else:
20889 
          iprot.skip(ftype)
20890 
      else:
20891 
        iprot.skip(ftype)
20892 
      iprot.readFieldEnd()
20893 
    iprot.readStructEnd()
20894 
 
20895 
  def write(self, oprot):
20896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20898 
      return
20899 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20900 
    if self.settlementId is not None:
20901 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20902 
      oprot.writeI64(self.settlementId)
20903 
      oprot.writeFieldEnd()
20904 
    if self.settlementDate is not None:
20905 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20906 
      oprot.writeI64(self.settlementDate)
20907 
      oprot.writeFieldEnd()
20908 
    if self.transactionDateFrom is not None:
20909 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20910 
      oprot.writeI64(self.transactionDateFrom)
20911 
      oprot.writeFieldEnd()
20912 
    if self.transactionDateTo is not None:
20913 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20914 
      oprot.writeI64(self.transactionDateTo)
20915 
      oprot.writeFieldEnd()
20916 
    if self.amount is not None:
20917 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20918 
      oprot.writeDouble(self.amount)
20919 
      oprot.writeFieldEnd()
20920 
    oprot.writeFieldStop()
20921 
    oprot.writeStructEnd()
20922 
 
20923 
  def validate(self):
20924 
    return
20925 
 
20926 
 
20927 
  def __repr__(self):
20928 
    L = ['%s=%r' % (key, value)
20929 
      for key, value in self.__dict__.iteritems()]
20930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20931 
 
20932 
  def __eq__(self, other):
20933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20934 
 
20935 
  def __ne__(self, other):
20936 
    return not (self == other)
20937 
 
20938 
class saveEBSSettlementSummary_result:
20939 
  """
20940 
  Attributes:
20941 
   - ex
20942 
  """
20943 
 
20944 
  thrift_spec = (
20945 
    None, # 0
20946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20947 
  )
20948 
 
20949 
  def __init__(self, ex=None,):
20950 
    self.ex = ex
20951 
 
20952 
  def read(self, iprot):
20953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20955 
      return
20956 
    iprot.readStructBegin()
20957 
    while True:
20958 
      (fname, ftype, fid) = iprot.readFieldBegin()
20959 
      if ftype == TType.STOP:
20960 
        break
20961 
      if fid == 1:
20962 
        if ftype == TType.STRUCT:
20963 
          self.ex = TransactionServiceException()
20964 
          self.ex.read(iprot)
20965 
        else:
20966 
          iprot.skip(ftype)
20967 
      else:
20968 
        iprot.skip(ftype)
20969 
      iprot.readFieldEnd()
20970 
    iprot.readStructEnd()
20971 
 
20972 
  def write(self, oprot):
20973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20975 
      return
20976 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20977 
    if self.ex is not None:
20978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20979 
      self.ex.write(oprot)
20980 
      oprot.writeFieldEnd()
20981 
    oprot.writeFieldStop()
20982 
    oprot.writeStructEnd()
20983 
 
20984 
  def validate(self):
20985 
    return
20986 
 
20987 
 
20988 
  def __repr__(self):
20989 
    L = ['%s=%r' % (key, value)
20990 
      for key, value in self.__dict__.iteritems()]
20991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20992 
 
20993 
  def __eq__(self, other):
20994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20995 
 
20996 
  def __ne__(self, other):
20997 
    return not (self == other)
20998 
 
5386 phani.kuma 20999 
class getSettlementForPrepaid_args:
4600 varun.gupt 21000 
  """
21001 
  Attributes:
5189 varun.gupt 21002 
   - referenceId
21003 
   - isRefund
4600 varun.gupt 21004 
  """
21005 
 
21006 
  thrift_spec = (
21007 
    None, # 0
5189 varun.gupt 21008 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 21009 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 21010 
  )
21011 
 
5386 phani.kuma 21012 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 21013 
    self.referenceId = referenceId
21014 
    self.isRefund = isRefund
4600 varun.gupt 21015 
 
21016 
  def read(self, iprot):
21017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21019 
      return
21020 
    iprot.readStructBegin()
21021 
    while True:
21022 
      (fname, ftype, fid) = iprot.readFieldBegin()
21023 
      if ftype == TType.STOP:
21024 
        break
21025 
      if fid == 1:
21026 
        if ftype == TType.I64:
5189 varun.gupt 21027 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21028 
        else:
21029 
          iprot.skip(ftype)
5189 varun.gupt 21030 
      elif fid == 2:
21031 
        if ftype == TType.BOOL:
21032 
          self.isRefund = iprot.readBool();
21033 
        else:
21034 
          iprot.skip(ftype)
4600 varun.gupt 21035 
      else:
21036 
        iprot.skip(ftype)
21037 
      iprot.readFieldEnd()
21038 
    iprot.readStructEnd()
21039 
 
21040 
  def write(self, oprot):
21041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21043 
      return
5386 phani.kuma 21044 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 21045 
    if self.referenceId is not None:
21046 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
21047 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21048 
      oprot.writeFieldEnd()
5386 phani.kuma 21049 
    if self.isRefund is not None:
21050 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
21051 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 21052 
      oprot.writeFieldEnd()
5386 phani.kuma 21053 
    oprot.writeFieldStop()
21054 
    oprot.writeStructEnd()
21055 
 
21056 
  def validate(self):
21057 
    return
21058 
 
21059 
 
21060 
  def __repr__(self):
21061 
    L = ['%s=%r' % (key, value)
21062 
      for key, value in self.__dict__.iteritems()]
21063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21064 
 
21065 
  def __eq__(self, other):
21066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21067 
 
21068 
  def __ne__(self, other):
21069 
    return not (self == other)
21070 
 
21071 
class getSettlementForPrepaid_result:
21072 
  """
21073 
  Attributes:
21074 
   - success
21075 
   - ex
21076 
  """
21077 
 
21078 
  thrift_spec = (
21079 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21081 
  )
21082 
 
21083 
  def __init__(self, success=None, ex=None,):
21084 
    self.success = success
21085 
    self.ex = ex
21086 
 
21087 
  def read(self, iprot):
21088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21090 
      return
21091 
    iprot.readStructBegin()
21092 
    while True:
21093 
      (fname, ftype, fid) = iprot.readFieldBegin()
21094 
      if ftype == TType.STOP:
21095 
        break
21096 
      if fid == 0:
21097 
        if ftype == TType.STRUCT:
21098 
          self.success = PaymentSettlement()
21099 
          self.success.read(iprot)
21100 
        else:
21101 
          iprot.skip(ftype)
21102 
      elif fid == 1:
21103 
        if ftype == TType.STRUCT:
21104 
          self.ex = TransactionServiceException()
21105 
          self.ex.read(iprot)
21106 
        else:
21107 
          iprot.skip(ftype)
21108 
      else:
21109 
        iprot.skip(ftype)
21110 
      iprot.readFieldEnd()
21111 
    iprot.readStructEnd()
21112 
 
21113 
  def write(self, oprot):
21114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21116 
      return
21117 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
21118 
    if self.success is not None:
21119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21120 
      self.success.write(oprot)
21121 
      oprot.writeFieldEnd()
21122 
    if self.ex is not None:
21123 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21124 
      self.ex.write(oprot)
21125 
      oprot.writeFieldEnd()
21126 
    oprot.writeFieldStop()
21127 
    oprot.writeStructEnd()
21128 
 
21129 
  def validate(self):
21130 
    return
21131 
 
21132 
 
21133 
  def __repr__(self):
21134 
    L = ['%s=%r' % (key, value)
21135 
      for key, value in self.__dict__.iteritems()]
21136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21137 
 
21138 
  def __eq__(self, other):
21139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21140 
 
21141 
  def __ne__(self, other):
21142 
    return not (self == other)
21143 
 
21144 
class getSettlementForCod_args:
21145 
  """
21146 
  Attributes:
21147 
   - orderId
21148 
   - isRefund
21149 
  """
21150 
 
21151 
  thrift_spec = (
21152 
    None, # 0
21153 
    (1, TType.I64, 'orderId', None, None, ), # 1
21154 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
21155 
  )
21156 
 
21157 
  def __init__(self, orderId=None, isRefund=None,):
21158 
    self.orderId = orderId
21159 
    self.isRefund = isRefund
21160 
 
21161 
  def read(self, iprot):
21162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21164 
      return
21165 
    iprot.readStructBegin()
21166 
    while True:
21167 
      (fname, ftype, fid) = iprot.readFieldBegin()
21168 
      if ftype == TType.STOP:
21169 
        break
21170 
      if fid == 1:
21171 
        if ftype == TType.I64:
21172 
          self.orderId = iprot.readI64();
21173 
        else:
21174 
          iprot.skip(ftype)
21175 
      elif fid == 2:
21176 
        if ftype == TType.BOOL:
21177 
          self.isRefund = iprot.readBool();
21178 
        else:
21179 
          iprot.skip(ftype)
21180 
      else:
21181 
        iprot.skip(ftype)
21182 
      iprot.readFieldEnd()
21183 
    iprot.readStructEnd()
21184 
 
21185 
  def write(self, oprot):
21186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21188 
      return
21189 
    oprot.writeStructBegin('getSettlementForCod_args')
21190 
    if self.orderId is not None:
21191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21192 
      oprot.writeI64(self.orderId)
21193 
      oprot.writeFieldEnd()
5189 varun.gupt 21194 
    if self.isRefund is not None:
5386 phani.kuma 21195 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 21196 
      oprot.writeBool(self.isRefund)
21197 
      oprot.writeFieldEnd()
4600 varun.gupt 21198 
    oprot.writeFieldStop()
21199 
    oprot.writeStructEnd()
21200 
 
21201 
  def validate(self):
21202 
    return
21203 
 
21204 
 
21205 
  def __repr__(self):
21206 
    L = ['%s=%r' % (key, value)
21207 
      for key, value in self.__dict__.iteritems()]
21208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21209 
 
21210 
  def __eq__(self, other):
21211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21212 
 
21213 
  def __ne__(self, other):
21214 
    return not (self == other)
21215 
 
5386 phani.kuma 21216 
class getSettlementForCod_result:
4600 varun.gupt 21217 
  """
21218 
  Attributes:
21219 
   - success
21220 
   - ex
21221 
  """
21222 
 
21223 
  thrift_spec = (
21224 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
21225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21226 
  )
21227 
 
21228 
  def __init__(self, success=None, ex=None,):
21229 
    self.success = success
21230 
    self.ex = ex
21231 
 
21232 
  def read(self, iprot):
21233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21235 
      return
21236 
    iprot.readStructBegin()
21237 
    while True:
21238 
      (fname, ftype, fid) = iprot.readFieldBegin()
21239 
      if ftype == TType.STOP:
21240 
        break
21241 
      if fid == 0:
21242 
        if ftype == TType.STRUCT:
21243 
          self.success = PaymentSettlement()
21244 
          self.success.read(iprot)
21245 
        else:
21246 
          iprot.skip(ftype)
21247 
      elif fid == 1:
21248 
        if ftype == TType.STRUCT:
21249 
          self.ex = TransactionServiceException()
21250 
          self.ex.read(iprot)
21251 
        else:
21252 
          iprot.skip(ftype)
21253 
      else:
21254 
        iprot.skip(ftype)
21255 
      iprot.readFieldEnd()
21256 
    iprot.readStructEnd()
21257 
 
21258 
  def write(self, oprot):
21259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21261 
      return
5386 phani.kuma 21262 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 21263 
    if self.success is not None:
21264 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21265 
      self.success.write(oprot)
21266 
      oprot.writeFieldEnd()
21267 
    if self.ex is not None:
21268 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21269 
      self.ex.write(oprot)
21270 
      oprot.writeFieldEnd()
21271 
    oprot.writeFieldStop()
21272 
    oprot.writeStructEnd()
21273 
 
21274 
  def validate(self):
21275 
    return
21276 
 
21277 
 
21278 
  def __repr__(self):
21279 
    L = ['%s=%r' % (key, value)
21280 
      for key, value in self.__dict__.iteritems()]
21281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21282 
 
21283 
  def __eq__(self, other):
21284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21285 
 
21286 
  def __ne__(self, other):
21287 
    return not (self == other)
21288 
 
21289 
class getEBSSettlementSummaries_args:
21290 
 
21291 
  thrift_spec = (
21292 
  )
21293 
 
21294 
  def read(self, iprot):
21295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21297 
      return
21298 
    iprot.readStructBegin()
21299 
    while True:
21300 
      (fname, ftype, fid) = iprot.readFieldBegin()
21301 
      if ftype == TType.STOP:
21302 
        break
21303 
      else:
21304 
        iprot.skip(ftype)
21305 
      iprot.readFieldEnd()
21306 
    iprot.readStructEnd()
21307 
 
21308 
  def write(self, oprot):
21309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21311 
      return
21312 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
21313 
    oprot.writeFieldStop()
21314 
    oprot.writeStructEnd()
21315 
 
21316 
  def validate(self):
21317 
    return
21318 
 
21319 
 
21320 
  def __repr__(self):
21321 
    L = ['%s=%r' % (key, value)
21322 
      for key, value in self.__dict__.iteritems()]
21323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21324 
 
21325 
  def __eq__(self, other):
21326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21327 
 
21328 
  def __ne__(self, other):
21329 
    return not (self == other)
21330 
 
21331 
class getEBSSettlementSummaries_result:
21332 
  """
21333 
  Attributes:
21334 
   - success
21335 
   - ex
21336 
  """
21337 
 
21338 
  thrift_spec = (
21339 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
21340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21341 
  )
21342 
 
21343 
  def __init__(self, success=None, ex=None,):
21344 
    self.success = success
21345 
    self.ex = ex
21346 
 
21347 
  def read(self, iprot):
21348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21350 
      return
21351 
    iprot.readStructBegin()
21352 
    while True:
21353 
      (fname, ftype, fid) = iprot.readFieldBegin()
21354 
      if ftype == TType.STOP:
21355 
        break
21356 
      if fid == 0:
21357 
        if ftype == TType.MAP:
21358 
          self.success = {}
5411 rajveer 21359 
          (_ktype491, _vtype492, _size490 ) = iprot.readMapBegin()
21360 
          for _i494 in xrange(_size490):
21361 
            _key495 = iprot.readI64();
21362 
            _val496 = iprot.readString();
21363 
            self.success[_key495] = _val496
4600 varun.gupt 21364 
          iprot.readMapEnd()
21365 
        else:
21366 
          iprot.skip(ftype)
21367 
      elif fid == 1:
21368 
        if ftype == TType.STRUCT:
21369 
          self.ex = TransactionServiceException()
21370 
          self.ex.read(iprot)
21371 
        else:
21372 
          iprot.skip(ftype)
21373 
      else:
21374 
        iprot.skip(ftype)
21375 
      iprot.readFieldEnd()
21376 
    iprot.readStructEnd()
21377 
 
21378 
  def write(self, oprot):
21379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21381 
      return
21382 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
21383 
    if self.success is not None:
21384 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21385 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5411 rajveer 21386 
      for kiter497,viter498 in self.success.items():
21387 
        oprot.writeI64(kiter497)
21388 
        oprot.writeString(viter498)
4600 varun.gupt 21389 
      oprot.writeMapEnd()
21390 
      oprot.writeFieldEnd()
21391 
    if self.ex is not None:
21392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21393 
      self.ex.write(oprot)
21394 
      oprot.writeFieldEnd()
21395 
    oprot.writeFieldStop()
21396 
    oprot.writeStructEnd()
21397 
 
21398 
  def validate(self):
21399 
    return
21400 
 
21401 
 
21402 
  def __repr__(self):
21403 
    L = ['%s=%r' % (key, value)
21404 
      for key, value in self.__dict__.iteritems()]
21405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21406 
 
21407 
  def __eq__(self, other):
21408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21409 
 
21410 
  def __ne__(self, other):
21411 
    return not (self == other)
21412 
 
21413 
class markEBSSettlementUploaded_args:
21414 
  """
21415 
  Attributes:
21416 
   - settlementId
21417 
  """
21418 
 
21419 
  thrift_spec = (
21420 
    None, # 0
21421 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21422 
  )
21423 
 
21424 
  def __init__(self, settlementId=None,):
21425 
    self.settlementId = settlementId
21426 
 
21427 
  def read(self, iprot):
21428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21430 
      return
21431 
    iprot.readStructBegin()
21432 
    while True:
21433 
      (fname, ftype, fid) = iprot.readFieldBegin()
21434 
      if ftype == TType.STOP:
21435 
        break
21436 
      if fid == 1:
21437 
        if ftype == TType.I64:
21438 
          self.settlementId = iprot.readI64();
21439 
        else:
21440 
          iprot.skip(ftype)
21441 
      else:
21442 
        iprot.skip(ftype)
21443 
      iprot.readFieldEnd()
21444 
    iprot.readStructEnd()
21445 
 
21446 
  def write(self, oprot):
21447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21449 
      return
21450 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
21451 
    if self.settlementId is not None:
21452 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21453 
      oprot.writeI64(self.settlementId)
21454 
      oprot.writeFieldEnd()
21455 
    oprot.writeFieldStop()
21456 
    oprot.writeStructEnd()
21457 
 
21458 
  def validate(self):
21459 
    return
21460 
 
21461 
 
21462 
  def __repr__(self):
21463 
    L = ['%s=%r' % (key, value)
21464 
      for key, value in self.__dict__.iteritems()]
21465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21466 
 
21467 
  def __eq__(self, other):
21468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21469 
 
21470 
  def __ne__(self, other):
21471 
    return not (self == other)
21472 
 
21473 
class markEBSSettlementUploaded_result:
21474 
  """
21475 
  Attributes:
21476 
   - ex
21477 
  """
21478 
 
21479 
  thrift_spec = (
21480 
    None, # 0
21481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21482 
  )
21483 
 
21484 
  def __init__(self, ex=None,):
21485 
    self.ex = ex
21486 
 
21487 
  def read(self, iprot):
21488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21490 
      return
21491 
    iprot.readStructBegin()
21492 
    while True:
21493 
      (fname, ftype, fid) = iprot.readFieldBegin()
21494 
      if ftype == TType.STOP:
21495 
        break
21496 
      if fid == 1:
21497 
        if ftype == TType.STRUCT:
21498 
          self.ex = TransactionServiceException()
21499 
          self.ex.read(iprot)
21500 
        else:
21501 
          iprot.skip(ftype)
21502 
      else:
21503 
        iprot.skip(ftype)
21504 
      iprot.readFieldEnd()
21505 
    iprot.readStructEnd()
21506 
 
21507 
  def write(self, oprot):
21508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21510 
      return
21511 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21512 
    if self.ex is not None:
21513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21514 
      self.ex.write(oprot)
21515 
      oprot.writeFieldEnd()
21516 
    oprot.writeFieldStop()
21517 
    oprot.writeStructEnd()
21518 
 
21519 
  def validate(self):
21520 
    return
21521 
 
21522 
 
21523 
  def __repr__(self):
21524 
    L = ['%s=%r' % (key, value)
21525 
      for key, value in self.__dict__.iteritems()]
21526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21527 
 
21528 
  def __eq__(self, other):
21529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21530 
 
21531 
  def __ne__(self, other):
21532 
    return not (self == other)
21533 
 
21534 
class getEBSSettlementDate_args:
21535 
  """
21536 
  Attributes:
21537 
   - settlementId
21538 
  """
21539 
 
21540 
  thrift_spec = (
21541 
    None, # 0
21542 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21543 
  )
21544 
 
21545 
  def __init__(self, settlementId=None,):
21546 
    self.settlementId = settlementId
21547 
 
21548 
  def read(self, iprot):
21549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21551 
      return
21552 
    iprot.readStructBegin()
21553 
    while True:
21554 
      (fname, ftype, fid) = iprot.readFieldBegin()
21555 
      if ftype == TType.STOP:
21556 
        break
21557 
      if fid == 1:
21558 
        if ftype == TType.I64:
21559 
          self.settlementId = iprot.readI64();
21560 
        else:
21561 
          iprot.skip(ftype)
21562 
      else:
21563 
        iprot.skip(ftype)
21564 
      iprot.readFieldEnd()
21565 
    iprot.readStructEnd()
21566 
 
21567 
  def write(self, oprot):
21568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21570 
      return
21571 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21572 
    if self.settlementId is not None:
21573 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21574 
      oprot.writeI64(self.settlementId)
21575 
      oprot.writeFieldEnd()
21576 
    oprot.writeFieldStop()
21577 
    oprot.writeStructEnd()
21578 
 
21579 
  def validate(self):
21580 
    return
21581 
 
21582 
 
21583 
  def __repr__(self):
21584 
    L = ['%s=%r' % (key, value)
21585 
      for key, value in self.__dict__.iteritems()]
21586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21587 
 
21588 
  def __eq__(self, other):
21589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21590 
 
21591 
  def __ne__(self, other):
21592 
    return not (self == other)
21593 
 
21594 
class getEBSSettlementDate_result:
21595 
  """
21596 
  Attributes:
21597 
   - success
21598 
   - ex
21599 
  """
21600 
 
21601 
  thrift_spec = (
21602 
    (0, TType.I64, 'success', None, None, ), # 0
21603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21604 
  )
21605 
 
21606 
  def __init__(self, success=None, ex=None,):
21607 
    self.success = success
21608 
    self.ex = ex
21609 
 
21610 
  def read(self, iprot):
21611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21613 
      return
21614 
    iprot.readStructBegin()
21615 
    while True:
21616 
      (fname, ftype, fid) = iprot.readFieldBegin()
21617 
      if ftype == TType.STOP:
21618 
        break
21619 
      if fid == 0:
21620 
        if ftype == TType.I64:
21621 
          self.success = iprot.readI64();
21622 
        else:
21623 
          iprot.skip(ftype)
21624 
      elif fid == 1:
21625 
        if ftype == TType.STRUCT:
21626 
          self.ex = TransactionServiceException()
21627 
          self.ex.read(iprot)
21628 
        else:
21629 
          iprot.skip(ftype)
21630 
      else:
21631 
        iprot.skip(ftype)
21632 
      iprot.readFieldEnd()
21633 
    iprot.readStructEnd()
21634 
 
21635 
  def write(self, oprot):
21636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21638 
      return
21639 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21640 
    if self.success is not None:
21641 
      oprot.writeFieldBegin('success', TType.I64, 0)
21642 
      oprot.writeI64(self.success)
21643 
      oprot.writeFieldEnd()
21644 
    if self.ex is not None:
21645 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21646 
      self.ex.write(oprot)
21647 
      oprot.writeFieldEnd()
21648 
    oprot.writeFieldStop()
21649 
    oprot.writeStructEnd()
21650 
 
21651 
  def validate(self):
21652 
    return
21653 
 
21654 
 
21655 
  def __repr__(self):
21656 
    L = ['%s=%r' % (key, value)
21657 
      for key, value in self.__dict__.iteritems()]
21658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21659 
 
21660 
  def __eq__(self, other):
21661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21662 
 
21663 
  def __ne__(self, other):
21664 
    return not (self == other)
4715 varun.gupt 21665 
 
21666 
class getSettlementsByDate_args:
21667 
  """
21668 
  Attributes:
21669 
   - settlementDateFrom
21670 
   - settlementDateTo
21671 
   - isRefund
21672 
  """
21673 
 
21674 
  thrift_spec = (
21675 
    None, # 0
21676 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21677 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21678 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21679 
  )
21680 
 
21681 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21682 
    self.settlementDateFrom = settlementDateFrom
21683 
    self.settlementDateTo = settlementDateTo
21684 
    self.isRefund = isRefund
21685 
 
21686 
  def read(self, iprot):
21687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21689 
      return
21690 
    iprot.readStructBegin()
21691 
    while True:
21692 
      (fname, ftype, fid) = iprot.readFieldBegin()
21693 
      if ftype == TType.STOP:
21694 
        break
21695 
      if fid == 1:
21696 
        if ftype == TType.I64:
21697 
          self.settlementDateFrom = iprot.readI64();
21698 
        else:
21699 
          iprot.skip(ftype)
21700 
      elif fid == 2:
21701 
        if ftype == TType.I64:
21702 
          self.settlementDateTo = iprot.readI64();
21703 
        else:
21704 
          iprot.skip(ftype)
21705 
      elif fid == 3:
21706 
        if ftype == TType.BOOL:
21707 
          self.isRefund = iprot.readBool();
21708 
        else:
21709 
          iprot.skip(ftype)
21710 
      else:
21711 
        iprot.skip(ftype)
21712 
      iprot.readFieldEnd()
21713 
    iprot.readStructEnd()
21714 
 
21715 
  def write(self, oprot):
21716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21718 
      return
21719 
    oprot.writeStructBegin('getSettlementsByDate_args')
21720 
    if self.settlementDateFrom is not None:
21721 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21722 
      oprot.writeI64(self.settlementDateFrom)
21723 
      oprot.writeFieldEnd()
21724 
    if self.settlementDateTo is not None:
21725 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21726 
      oprot.writeI64(self.settlementDateTo)
21727 
      oprot.writeFieldEnd()
21728 
    if self.isRefund is not None:
21729 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21730 
      oprot.writeBool(self.isRefund)
21731 
      oprot.writeFieldEnd()
21732 
    oprot.writeFieldStop()
21733 
    oprot.writeStructEnd()
21734 
 
21735 
  def validate(self):
21736 
    return
21737 
 
21738 
 
21739 
  def __repr__(self):
21740 
    L = ['%s=%r' % (key, value)
21741 
      for key, value in self.__dict__.iteritems()]
21742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21743 
 
21744 
  def __eq__(self, other):
21745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21746 
 
21747 
  def __ne__(self, other):
21748 
    return not (self == other)
21749 
 
21750 
class getSettlementsByDate_result:
21751 
  """
21752 
  Attributes:
21753 
   - success
21754 
   - ex
21755 
  """
21756 
 
21757 
  thrift_spec = (
21758 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21760 
  )
21761 
 
21762 
  def __init__(self, success=None, ex=None,):
21763 
    self.success = success
21764 
    self.ex = ex
21765 
 
21766 
  def read(self, iprot):
21767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21769 
      return
21770 
    iprot.readStructBegin()
21771 
    while True:
21772 
      (fname, ftype, fid) = iprot.readFieldBegin()
21773 
      if ftype == TType.STOP:
21774 
        break
21775 
      if fid == 0:
21776 
        if ftype == TType.LIST:
21777 
          self.success = []
5411 rajveer 21778 
          (_etype502, _size499) = iprot.readListBegin()
21779 
          for _i503 in xrange(_size499):
21780 
            _elem504 = PaymentSettlement()
21781 
            _elem504.read(iprot)
21782 
            self.success.append(_elem504)
4715 varun.gupt 21783 
          iprot.readListEnd()
21784 
        else:
21785 
          iprot.skip(ftype)
21786 
      elif fid == 1:
21787 
        if ftype == TType.STRUCT:
21788 
          self.ex = TransactionServiceException()
21789 
          self.ex.read(iprot)
21790 
        else:
21791 
          iprot.skip(ftype)
21792 
      else:
21793 
        iprot.skip(ftype)
21794 
      iprot.readFieldEnd()
21795 
    iprot.readStructEnd()
21796 
 
21797 
  def write(self, oprot):
21798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21800 
      return
21801 
    oprot.writeStructBegin('getSettlementsByDate_result')
21802 
    if self.success is not None:
21803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 21805 
      for iter505 in self.success:
21806 
        iter505.write(oprot)
4715 varun.gupt 21807 
      oprot.writeListEnd()
21808 
      oprot.writeFieldEnd()
21809 
    if self.ex is not None:
21810 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21811 
      self.ex.write(oprot)
21812 
      oprot.writeFieldEnd()
21813 
    oprot.writeFieldStop()
21814 
    oprot.writeStructEnd()
21815 
 
21816 
  def validate(self):
21817 
    return
21818 
 
21819 
 
21820 
  def __repr__(self):
21821 
    L = ['%s=%r' % (key, value)
21822 
      for key, value in self.__dict__.iteritems()]
21823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21824 
 
21825 
  def __eq__(self, other):
21826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21827 
 
21828 
  def __ne__(self, other):
21829 
    return not (self == other)
21830 
 
21831 
class getReshippedOrderIds_args:
21832 
  """
21833 
  Attributes:
21834 
   - orderIds
21835 
  """
21836 
 
21837 
  thrift_spec = (
21838 
    None, # 0
21839 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21840 
  )
21841 
 
21842 
  def __init__(self, orderIds=None,):
21843 
    self.orderIds = orderIds
21844 
 
21845 
  def read(self, iprot):
21846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21848 
      return
21849 
    iprot.readStructBegin()
21850 
    while True:
21851 
      (fname, ftype, fid) = iprot.readFieldBegin()
21852 
      if ftype == TType.STOP:
21853 
        break
21854 
      if fid == 1:
21855 
        if ftype == TType.LIST:
21856 
          self.orderIds = []
5411 rajveer 21857 
          (_etype509, _size506) = iprot.readListBegin()
21858 
          for _i510 in xrange(_size506):
21859 
            _elem511 = iprot.readI64();
21860 
            self.orderIds.append(_elem511)
4715 varun.gupt 21861 
          iprot.readListEnd()
21862 
        else:
21863 
          iprot.skip(ftype)
21864 
      else:
21865 
        iprot.skip(ftype)
21866 
      iprot.readFieldEnd()
21867 
    iprot.readStructEnd()
21868 
 
21869 
  def write(self, oprot):
21870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21872 
      return
21873 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21874 
    if self.orderIds is not None:
21875 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21876 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 21877 
      for iter512 in self.orderIds:
21878 
        oprot.writeI64(iter512)
4715 varun.gupt 21879 
      oprot.writeListEnd()
21880 
      oprot.writeFieldEnd()
21881 
    oprot.writeFieldStop()
21882 
    oprot.writeStructEnd()
21883 
 
21884 
  def validate(self):
21885 
    return
21886 
 
21887 
 
21888 
  def __repr__(self):
21889 
    L = ['%s=%r' % (key, value)
21890 
      for key, value in self.__dict__.iteritems()]
21891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21892 
 
21893 
  def __eq__(self, other):
21894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21895 
 
21896 
  def __ne__(self, other):
21897 
    return not (self == other)
21898 
 
21899 
class getReshippedOrderIds_result:
21900 
  """
21901 
  Attributes:
21902 
   - success
21903 
   - ex
21904 
  """
21905 
 
21906 
  thrift_spec = (
21907 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21909 
  )
21910 
 
21911 
  def __init__(self, success=None, ex=None,):
21912 
    self.success = success
21913 
    self.ex = ex
21914 
 
21915 
  def read(self, iprot):
21916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21918 
      return
21919 
    iprot.readStructBegin()
21920 
    while True:
21921 
      (fname, ftype, fid) = iprot.readFieldBegin()
21922 
      if ftype == TType.STOP:
21923 
        break
21924 
      if fid == 0:
21925 
        if ftype == TType.LIST:
21926 
          self.success = []
5411 rajveer 21927 
          (_etype516, _size513) = iprot.readListBegin()
21928 
          for _i517 in xrange(_size513):
21929 
            _elem518 = iprot.readI64();
21930 
            self.success.append(_elem518)
4715 varun.gupt 21931 
          iprot.readListEnd()
21932 
        else:
21933 
          iprot.skip(ftype)
21934 
      elif fid == 1:
21935 
        if ftype == TType.STRUCT:
21936 
          self.ex = TransactionServiceException()
21937 
          self.ex.read(iprot)
21938 
        else:
21939 
          iprot.skip(ftype)
21940 
      else:
21941 
        iprot.skip(ftype)
21942 
      iprot.readFieldEnd()
21943 
    iprot.readStructEnd()
21944 
 
21945 
  def write(self, oprot):
21946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21948 
      return
21949 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21950 
    if self.success is not None:
21951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21952 
      oprot.writeListBegin(TType.I64, len(self.success))
5411 rajveer 21953 
      for iter519 in self.success:
21954 
        oprot.writeI64(iter519)
4715 varun.gupt 21955 
      oprot.writeListEnd()
21956 
      oprot.writeFieldEnd()
21957 
    if self.ex is not None:
21958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21959 
      self.ex.write(oprot)
21960 
      oprot.writeFieldEnd()
21961 
    oprot.writeFieldStop()
21962 
    oprot.writeStructEnd()
21963 
 
21964 
  def validate(self):
21965 
    return
21966 
 
21967 
 
21968 
  def __repr__(self):
21969 
    L = ['%s=%r' % (key, value)
21970 
      for key, value in self.__dict__.iteritems()]
21971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21972 
 
21973 
  def __eq__(self, other):
21974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21975 
 
21976 
  def __ne__(self, other):
21977 
    return not (self == other)
4757 mandeep.dh 21978 
 
4875 varun.gupt 21979 
class getOrdersWhereVendorNotPaid_args:
21980 
  """
21981 
  Attributes:
21982 
   - vendorId
21983 
  """
21984 
 
21985 
  thrift_spec = (
21986 
    None, # 0
21987 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21988 
  )
21989 
 
21990 
  def __init__(self, vendorId=None,):
21991 
    self.vendorId = vendorId
21992 
 
21993 
  def read(self, iprot):
21994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21996 
      return
21997 
    iprot.readStructBegin()
21998 
    while True:
21999 
      (fname, ftype, fid) = iprot.readFieldBegin()
22000 
      if ftype == TType.STOP:
22001 
        break
22002 
      if fid == 1:
22003 
        if ftype == TType.I64:
22004 
          self.vendorId = iprot.readI64();
22005 
        else:
22006 
          iprot.skip(ftype)
22007 
      else:
22008 
        iprot.skip(ftype)
22009 
      iprot.readFieldEnd()
22010 
    iprot.readStructEnd()
22011 
 
22012 
  def write(self, oprot):
22013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22015 
      return
22016 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
22017 
    if self.vendorId is not None:
22018 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22019 
      oprot.writeI64(self.vendorId)
22020 
      oprot.writeFieldEnd()
22021 
    oprot.writeFieldStop()
22022 
    oprot.writeStructEnd()
22023 
 
22024 
  def validate(self):
22025 
    return
22026 
 
22027 
 
22028 
  def __repr__(self):
22029 
    L = ['%s=%r' % (key, value)
22030 
      for key, value in self.__dict__.iteritems()]
22031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22032 
 
22033 
  def __eq__(self, other):
22034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22035 
 
22036 
  def __ne__(self, other):
22037 
    return not (self == other)
22038 
 
22039 
class getOrdersWhereVendorNotPaid_result:
22040 
  """
22041 
  Attributes:
22042 
   - success
22043 
   - ex
22044 
  """
22045 
 
22046 
  thrift_spec = (
22047 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22048 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22049 
  )
22050 
 
22051 
  def __init__(self, success=None, ex=None,):
22052 
    self.success = success
22053 
    self.ex = ex
22054 
 
22055 
  def read(self, iprot):
22056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22058 
      return
22059 
    iprot.readStructBegin()
22060 
    while True:
22061 
      (fname, ftype, fid) = iprot.readFieldBegin()
22062 
      if ftype == TType.STOP:
22063 
        break
22064 
      if fid == 0:
22065 
        if ftype == TType.LIST:
22066 
          self.success = []
5411 rajveer 22067 
          (_etype523, _size520) = iprot.readListBegin()
22068 
          for _i524 in xrange(_size520):
22069 
            _elem525 = Order()
22070 
            _elem525.read(iprot)
22071 
            self.success.append(_elem525)
4875 varun.gupt 22072 
          iprot.readListEnd()
22073 
        else:
22074 
          iprot.skip(ftype)
22075 
      elif fid == 1:
22076 
        if ftype == TType.STRUCT:
22077 
          self.ex = TransactionServiceException()
22078 
          self.ex.read(iprot)
22079 
        else:
22080 
          iprot.skip(ftype)
22081 
      else:
22082 
        iprot.skip(ftype)
22083 
      iprot.readFieldEnd()
22084 
    iprot.readStructEnd()
22085 
 
22086 
  def write(self, oprot):
22087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22089 
      return
22090 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
22091 
    if self.success is not None:
22092 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22093 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 22094 
      for iter526 in self.success:
22095 
        iter526.write(oprot)
4875 varun.gupt 22096 
      oprot.writeListEnd()
22097 
      oprot.writeFieldEnd()
22098 
    if self.ex is not None:
22099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22100 
      self.ex.write(oprot)
22101 
      oprot.writeFieldEnd()
22102 
    oprot.writeFieldStop()
22103 
    oprot.writeStructEnd()
22104 
 
22105 
  def validate(self):
22106 
    return
22107 
 
22108 
 
22109 
  def __repr__(self):
22110 
    L = ['%s=%r' % (key, value)
22111 
      for key, value in self.__dict__.iteritems()]
22112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22113 
 
22114 
  def __eq__(self, other):
22115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22116 
 
22117 
  def __ne__(self, other):
22118 
    return not (self == other)
5031 varun.gupt 22119 
 
22120 
class getStatusDistributionOfOrders_args:
22121 
  """
22122 
  Attributes:
22123 
   - startDate
22124 
   - endDate
22125 
  """
22126 
 
22127 
  thrift_spec = (
22128 
    None, # 0
22129 
    (1, TType.I64, 'startDate', None, None, ), # 1
22130 
    (2, TType.I64, 'endDate', None, None, ), # 2
22131 
  )
22132 
 
22133 
  def __init__(self, startDate=None, endDate=None,):
22134 
    self.startDate = startDate
22135 
    self.endDate = endDate
22136 
 
22137 
  def read(self, iprot):
22138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22140 
      return
22141 
    iprot.readStructBegin()
22142 
    while True:
22143 
      (fname, ftype, fid) = iprot.readFieldBegin()
22144 
      if ftype == TType.STOP:
22145 
        break
22146 
      if fid == 1:
22147 
        if ftype == TType.I64:
22148 
          self.startDate = iprot.readI64();
22149 
        else:
22150 
          iprot.skip(ftype)
22151 
      elif fid == 2:
22152 
        if ftype == TType.I64:
22153 
          self.endDate = iprot.readI64();
22154 
        else:
22155 
          iprot.skip(ftype)
22156 
      else:
22157 
        iprot.skip(ftype)
22158 
      iprot.readFieldEnd()
22159 
    iprot.readStructEnd()
22160 
 
22161 
  def write(self, oprot):
22162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22164 
      return
22165 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
22166 
    if self.startDate is not None:
22167 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
22168 
      oprot.writeI64(self.startDate)
22169 
      oprot.writeFieldEnd()
22170 
    if self.endDate is not None:
22171 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
22172 
      oprot.writeI64(self.endDate)
22173 
      oprot.writeFieldEnd()
22174 
    oprot.writeFieldStop()
22175 
    oprot.writeStructEnd()
22176 
 
22177 
  def validate(self):
22178 
    return
22179 
 
22180 
 
22181 
  def __repr__(self):
22182 
    L = ['%s=%r' % (key, value)
22183 
      for key, value in self.__dict__.iteritems()]
22184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22185 
 
22186 
  def __eq__(self, other):
22187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22188 
 
22189 
  def __ne__(self, other):
22190 
    return not (self == other)
22191 
 
22192 
class getStatusDistributionOfOrders_result:
22193 
  """
22194 
  Attributes:
22195 
   - success
22196 
   - ex
22197 
  """
22198 
 
22199 
  thrift_spec = (
22200 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
22201 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22202 
  )
22203 
 
22204 
  def __init__(self, success=None, ex=None,):
22205 
    self.success = success
22206 
    self.ex = ex
22207 
 
22208 
  def read(self, iprot):
22209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22211 
      return
22212 
    iprot.readStructBegin()
22213 
    while True:
22214 
      (fname, ftype, fid) = iprot.readFieldBegin()
22215 
      if ftype == TType.STOP:
22216 
        break
22217 
      if fid == 0:
22218 
        if ftype == TType.MAP:
22219 
          self.success = {}
5411 rajveer 22220 
          (_ktype528, _vtype529, _size527 ) = iprot.readMapBegin()
22221 
          for _i531 in xrange(_size527):
22222 
            _key532 = iprot.readI64();
22223 
            _val533 = iprot.readI64();
22224 
            self.success[_key532] = _val533
5031 varun.gupt 22225 
          iprot.readMapEnd()
22226 
        else:
22227 
          iprot.skip(ftype)
22228 
      elif fid == 1:
22229 
        if ftype == TType.STRUCT:
22230 
          self.ex = TransactionServiceException()
22231 
          self.ex.read(iprot)
22232 
        else:
22233 
          iprot.skip(ftype)
22234 
      else:
22235 
        iprot.skip(ftype)
22236 
      iprot.readFieldEnd()
22237 
    iprot.readStructEnd()
22238 
 
22239 
  def write(self, oprot):
22240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22242 
      return
22243 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
22244 
    if self.success is not None:
22245 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22246 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5411 rajveer 22247 
      for kiter534,viter535 in self.success.items():
22248 
        oprot.writeI64(kiter534)
22249 
        oprot.writeI64(viter535)
5031 varun.gupt 22250 
      oprot.writeMapEnd()
22251 
      oprot.writeFieldEnd()
22252 
    if self.ex is not None:
22253 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22254 
      self.ex.write(oprot)
22255 
      oprot.writeFieldEnd()
22256 
    oprot.writeFieldStop()
22257 
    oprot.writeStructEnd()
22258 
 
22259 
  def validate(self):
22260 
    return
22261 
 
22262 
 
22263 
  def __repr__(self):
22264 
    L = ['%s=%r' % (key, value)
22265 
      for key, value in self.__dict__.iteritems()]
22266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22267 
 
22268 
  def __eq__(self, other):
22269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22270 
 
22271 
  def __ne__(self, other):
22272 
    return not (self == other)
5067 varun.gupt 22273 
 
22274 
class getOrderIdsForStatus_args:
22275 
  """
22276 
  Attributes:
22277 
   - status
22278 
   - startDatetime
22279 
   - endDatetime
22280 
  """
22281 
 
22282 
  thrift_spec = (
22283 
    None, # 0
22284 
    (1, TType.I64, 'status', None, None, ), # 1
22285 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
22286 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
22287 
  )
22288 
 
22289 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
22290 
    self.status = status
22291 
    self.startDatetime = startDatetime
22292 
    self.endDatetime = endDatetime
22293 
 
22294 
  def read(self, iprot):
22295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22297 
      return
22298 
    iprot.readStructBegin()
22299 
    while True:
22300 
      (fname, ftype, fid) = iprot.readFieldBegin()
22301 
      if ftype == TType.STOP:
22302 
        break
22303 
      if fid == 1:
22304 
        if ftype == TType.I64:
22305 
          self.status = iprot.readI64();
22306 
        else:
22307 
          iprot.skip(ftype)
22308 
      elif fid == 2:
22309 
        if ftype == TType.I64:
22310 
          self.startDatetime = iprot.readI64();
22311 
        else:
22312 
          iprot.skip(ftype)
22313 
      elif fid == 3:
22314 
        if ftype == TType.I64:
22315 
          self.endDatetime = iprot.readI64();
22316 
        else:
22317 
          iprot.skip(ftype)
22318 
      else:
22319 
        iprot.skip(ftype)
22320 
      iprot.readFieldEnd()
22321 
    iprot.readStructEnd()
22322 
 
22323 
  def write(self, oprot):
22324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22326 
      return
22327 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22328 
    if self.status is not None:
22329 
      oprot.writeFieldBegin('status', TType.I64, 1)
22330 
      oprot.writeI64(self.status)
22331 
      oprot.writeFieldEnd()
22332 
    if self.startDatetime is not None:
22333 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22334 
      oprot.writeI64(self.startDatetime)
22335 
      oprot.writeFieldEnd()
22336 
    if self.endDatetime is not None:
22337 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22338 
      oprot.writeI64(self.endDatetime)
22339 
      oprot.writeFieldEnd()
22340 
    oprot.writeFieldStop()
22341 
    oprot.writeStructEnd()
22342 
 
22343 
  def validate(self):
22344 
    return
22345 
 
22346 
 
22347 
  def __repr__(self):
22348 
    L = ['%s=%r' % (key, value)
22349 
      for key, value in self.__dict__.iteritems()]
22350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22351 
 
22352 
  def __eq__(self, other):
22353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22354 
 
22355 
  def __ne__(self, other):
22356 
    return not (self == other)
22357 
 
22358 
class getOrderIdsForStatus_result:
22359 
  """
22360 
  Attributes:
22361 
   - success
22362 
   - ex
22363 
  """
22364 
 
22365 
  thrift_spec = (
22366 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22368 
  )
22369 
 
22370 
  def __init__(self, success=None, ex=None,):
22371 
    self.success = success
22372 
    self.ex = ex
22373 
 
22374 
  def read(self, iprot):
22375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22377 
      return
22378 
    iprot.readStructBegin()
22379 
    while True:
22380 
      (fname, ftype, fid) = iprot.readFieldBegin()
22381 
      if ftype == TType.STOP:
22382 
        break
22383 
      if fid == 0:
22384 
        if ftype == TType.LIST:
22385 
          self.success = []
5411 rajveer 22386 
          (_etype539, _size536) = iprot.readListBegin()
22387 
          for _i540 in xrange(_size536):
22388 
            _elem541 = iprot.readI64();
22389 
            self.success.append(_elem541)
5067 varun.gupt 22390 
          iprot.readListEnd()
22391 
        else:
22392 
          iprot.skip(ftype)
22393 
      elif fid == 1:
22394 
        if ftype == TType.STRUCT:
22395 
          self.ex = TransactionServiceException()
22396 
          self.ex.read(iprot)
22397 
        else:
22398 
          iprot.skip(ftype)
22399 
      else:
22400 
        iprot.skip(ftype)
22401 
      iprot.readFieldEnd()
22402 
    iprot.readStructEnd()
22403 
 
22404 
  def write(self, oprot):
22405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22407 
      return
22408 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22409 
    if self.success is not None:
22410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22411 
      oprot.writeListBegin(TType.I64, len(self.success))
5411 rajveer 22412 
      for iter542 in self.success:
22413 
        oprot.writeI64(iter542)
5067 varun.gupt 22414 
      oprot.writeListEnd()
22415 
      oprot.writeFieldEnd()
22416 
    if self.ex is not None:
22417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22418 
      self.ex.write(oprot)
22419 
      oprot.writeFieldEnd()
22420 
    oprot.writeFieldStop()
22421 
    oprot.writeStructEnd()
22422 
 
22423 
  def validate(self):
22424 
    return
22425 
 
22426 
 
22427 
  def __repr__(self):
22428 
    L = ['%s=%r' % (key, value)
22429 
      for key, value in self.__dict__.iteritems()]
22430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22431 
 
22432 
  def __eq__(self, other):
22433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22434 
 
22435 
  def __ne__(self, other):
22436 
    return not (self == other)
5099 varun.gupt 22437 
 
5348 anupam.sin 22438 
class updateCODAgent_args:
22439 
  """
22440 
  Attributes:
22441 
   - agent
22442 
   - orderId
22443 
  """
22444 
 
22445 
  thrift_spec = (
22446 
    None, # 0
22447 
    (1, TType.STRING, 'agent', None, None, ), # 1
22448 
    (2, TType.I64, 'orderId', None, None, ), # 2
22449 
  )
22450 
 
22451 
  def __init__(self, agent=None, orderId=None,):
22452 
    self.agent = agent
22453 
    self.orderId = orderId
22454 
 
22455 
  def read(self, iprot):
22456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22458 
      return
22459 
    iprot.readStructBegin()
22460 
    while True:
22461 
      (fname, ftype, fid) = iprot.readFieldBegin()
22462 
      if ftype == TType.STOP:
22463 
        break
22464 
      if fid == 1:
22465 
        if ftype == TType.STRING:
22466 
          self.agent = iprot.readString();
22467 
        else:
22468 
          iprot.skip(ftype)
22469 
      elif fid == 2:
22470 
        if ftype == TType.I64:
22471 
          self.orderId = iprot.readI64();
22472 
        else:
22473 
          iprot.skip(ftype)
22474 
      else:
22475 
        iprot.skip(ftype)
22476 
      iprot.readFieldEnd()
22477 
    iprot.readStructEnd()
22478 
 
22479 
  def write(self, oprot):
22480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22482 
      return
22483 
    oprot.writeStructBegin('updateCODAgent_args')
22484 
    if self.agent is not None:
22485 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22486 
      oprot.writeString(self.agent)
22487 
      oprot.writeFieldEnd()
22488 
    if self.orderId is not None:
22489 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22490 
      oprot.writeI64(self.orderId)
22491 
      oprot.writeFieldEnd()
22492 
    oprot.writeFieldStop()
22493 
    oprot.writeStructEnd()
22494 
 
22495 
  def validate(self):
22496 
    return
22497 
 
22498 
 
22499 
  def __repr__(self):
22500 
    L = ['%s=%r' % (key, value)
22501 
      for key, value in self.__dict__.iteritems()]
22502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22503 
 
22504 
  def __eq__(self, other):
22505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22506 
 
22507 
  def __ne__(self, other):
22508 
    return not (self == other)
22509 
 
22510 
class updateCODAgent_result:
22511 
  """
22512 
  Attributes:
22513 
   - ex
22514 
  """
22515 
 
22516 
  thrift_spec = (
22517 
    None, # 0
22518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22519 
  )
22520 
 
22521 
  def __init__(self, ex=None,):
22522 
    self.ex = ex
22523 
 
22524 
  def read(self, iprot):
22525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22527 
      return
22528 
    iprot.readStructBegin()
22529 
    while True:
22530 
      (fname, ftype, fid) = iprot.readFieldBegin()
22531 
      if ftype == TType.STOP:
22532 
        break
22533 
      if fid == 1:
22534 
        if ftype == TType.STRUCT:
22535 
          self.ex = TransactionServiceException()
22536 
          self.ex.read(iprot)
22537 
        else:
22538 
          iprot.skip(ftype)
22539 
      else:
22540 
        iprot.skip(ftype)
22541 
      iprot.readFieldEnd()
22542 
    iprot.readStructEnd()
22543 
 
22544 
  def write(self, oprot):
22545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22547 
      return
22548 
    oprot.writeStructBegin('updateCODAgent_result')
22549 
    if self.ex is not None:
22550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22551 
      self.ex.write(oprot)
22552 
      oprot.writeFieldEnd()
22553 
    oprot.writeFieldStop()
22554 
    oprot.writeStructEnd()
22555 
 
22556 
  def validate(self):
22557 
    return
22558 
 
22559 
 
22560 
  def __repr__(self):
22561 
    L = ['%s=%r' % (key, value)
22562 
      for key, value in self.__dict__.iteritems()]
22563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22564 
 
22565 
  def __eq__(self, other):
22566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22567 
 
22568 
  def __ne__(self, other):
22569 
    return not (self == other)
22570 
 
5099 varun.gupt 22571 
class updateOrderAsPaidToVendor_args:
22572 
  """
22573 
  Attributes:
22574 
   - orderId
22575 
  """
22576 
 
22577 
  thrift_spec = (
22578 
    None, # 0
22579 
    (1, TType.I64, 'orderId', None, None, ), # 1
22580 
  )
22581 
 
22582 
  def __init__(self, orderId=None,):
22583 
    self.orderId = orderId
22584 
 
22585 
  def read(self, iprot):
22586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22588 
      return
22589 
    iprot.readStructBegin()
22590 
    while True:
22591 
      (fname, ftype, fid) = iprot.readFieldBegin()
22592 
      if ftype == TType.STOP:
22593 
        break
22594 
      if fid == 1:
22595 
        if ftype == TType.I64:
22596 
          self.orderId = iprot.readI64();
22597 
        else:
22598 
          iprot.skip(ftype)
22599 
      else:
22600 
        iprot.skip(ftype)
22601 
      iprot.readFieldEnd()
22602 
    iprot.readStructEnd()
22603 
 
22604 
  def write(self, oprot):
22605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22607 
      return
22608 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22609 
    if self.orderId is not None:
22610 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22611 
      oprot.writeI64(self.orderId)
22612 
      oprot.writeFieldEnd()
22613 
    oprot.writeFieldStop()
22614 
    oprot.writeStructEnd()
22615 
 
22616 
  def validate(self):
22617 
    return
22618 
 
22619 
 
22620 
  def __repr__(self):
22621 
    L = ['%s=%r' % (key, value)
22622 
      for key, value in self.__dict__.iteritems()]
22623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22624 
 
22625 
  def __eq__(self, other):
22626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22627 
 
22628 
  def __ne__(self, other):
22629 
    return not (self == other)
22630 
 
22631 
class updateOrderAsPaidToVendor_result:
22632 
  """
22633 
  Attributes:
22634 
   - ex
22635 
  """
22636 
 
22637 
  thrift_spec = (
22638 
    None, # 0
22639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22640 
  )
22641 
 
22642 
  def __init__(self, ex=None,):
22643 
    self.ex = ex
22644 
 
22645 
  def read(self, iprot):
22646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22648 
      return
22649 
    iprot.readStructBegin()
22650 
    while True:
22651 
      (fname, ftype, fid) = iprot.readFieldBegin()
22652 
      if ftype == TType.STOP:
22653 
        break
22654 
      if fid == 1:
22655 
        if ftype == TType.STRUCT:
22656 
          self.ex = TransactionServiceException()
22657 
          self.ex.read(iprot)
22658 
        else:
22659 
          iprot.skip(ftype)
22660 
      else:
22661 
        iprot.skip(ftype)
22662 
      iprot.readFieldEnd()
22663 
    iprot.readStructEnd()
22664 
 
22665 
  def write(self, oprot):
22666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22668 
      return
22669 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22670 
    if self.ex is not None:
22671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22672 
      self.ex.write(oprot)
22673 
      oprot.writeFieldEnd()
22674 
    oprot.writeFieldStop()
22675 
    oprot.writeStructEnd()
22676 
 
22677 
  def validate(self):
22678 
    return
22679 
 
22680 
 
22681 
  def __repr__(self):
22682 
    L = ['%s=%r' % (key, value)
22683 
      for key, value in self.__dict__.iteritems()]
22684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22685 
 
22686 
  def __eq__(self, other):
22687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22688 
 
22689 
  def __ne__(self, other):
22690 
    return not (self == other)
5208 varun.gupt 22691 
 
5386 phani.kuma 22692 
class updateOrderOnlyAsPaidToVendor_args:
22693 
  """
22694 
  Attributes:
22695 
   - orderId
22696 
  """
22697 
 
22698 
  thrift_spec = (
22699 
    None, # 0
22700 
    (1, TType.I64, 'orderId', None, None, ), # 1
22701 
  )
22702 
 
22703 
  def __init__(self, orderId=None,):
22704 
    self.orderId = orderId
22705 
 
22706 
  def read(self, iprot):
22707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22709 
      return
22710 
    iprot.readStructBegin()
22711 
    while True:
22712 
      (fname, ftype, fid) = iprot.readFieldBegin()
22713 
      if ftype == TType.STOP:
22714 
        break
22715 
      if fid == 1:
22716 
        if ftype == TType.I64:
22717 
          self.orderId = iprot.readI64();
22718 
        else:
22719 
          iprot.skip(ftype)
22720 
      else:
22721 
        iprot.skip(ftype)
22722 
      iprot.readFieldEnd()
22723 
    iprot.readStructEnd()
22724 
 
22725 
  def write(self, oprot):
22726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22728 
      return
22729 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
22730 
    if self.orderId is not None:
22731 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22732 
      oprot.writeI64(self.orderId)
22733 
      oprot.writeFieldEnd()
22734 
    oprot.writeFieldStop()
22735 
    oprot.writeStructEnd()
22736 
 
22737 
  def validate(self):
22738 
    return
22739 
 
22740 
 
22741 
  def __repr__(self):
22742 
    L = ['%s=%r' % (key, value)
22743 
      for key, value in self.__dict__.iteritems()]
22744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22745 
 
22746 
  def __eq__(self, other):
22747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22748 
 
22749 
  def __ne__(self, other):
22750 
    return not (self == other)
22751 
 
22752 
class updateOrderOnlyAsPaidToVendor_result:
22753 
  """
22754 
  Attributes:
22755 
   - ex
22756 
  """
22757 
 
22758 
  thrift_spec = (
22759 
    None, # 0
22760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22761 
  )
22762 
 
22763 
  def __init__(self, ex=None,):
22764 
    self.ex = ex
22765 
 
22766 
  def read(self, iprot):
22767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22769 
      return
22770 
    iprot.readStructBegin()
22771 
    while True:
22772 
      (fname, ftype, fid) = iprot.readFieldBegin()
22773 
      if ftype == TType.STOP:
22774 
        break
22775 
      if fid == 1:
22776 
        if ftype == TType.STRUCT:
22777 
          self.ex = TransactionServiceException()
22778 
          self.ex.read(iprot)
22779 
        else:
22780 
          iprot.skip(ftype)
22781 
      else:
22782 
        iprot.skip(ftype)
22783 
      iprot.readFieldEnd()
22784 
    iprot.readStructEnd()
22785 
 
22786 
  def write(self, oprot):
22787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22789 
      return
22790 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
22791 
    if self.ex is not None:
22792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22793 
      self.ex.write(oprot)
22794 
      oprot.writeFieldEnd()
22795 
    oprot.writeFieldStop()
22796 
    oprot.writeStructEnd()
22797 
 
22798 
  def validate(self):
22799 
    return
22800 
 
22801 
 
22802 
  def __repr__(self):
22803 
    L = ['%s=%r' % (key, value)
22804 
      for key, value in self.__dict__.iteritems()]
22805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22806 
 
22807 
  def __eq__(self, other):
22808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22809 
 
22810 
  def __ne__(self, other):
22811 
    return not (self == other)
22812 
 
5208 varun.gupt 22813 
class getRefundedOrdersMarkedPaid_args:
22814 
 
22815 
  thrift_spec = (
22816 
  )
22817 
 
22818 
  def read(self, iprot):
22819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22821 
      return
22822 
    iprot.readStructBegin()
22823 
    while True:
22824 
      (fname, ftype, fid) = iprot.readFieldBegin()
22825 
      if ftype == TType.STOP:
22826 
        break
22827 
      else:
22828 
        iprot.skip(ftype)
22829 
      iprot.readFieldEnd()
22830 
    iprot.readStructEnd()
22831 
 
22832 
  def write(self, oprot):
22833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22835 
      return
22836 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
22837 
    oprot.writeFieldStop()
22838 
    oprot.writeStructEnd()
22839 
 
22840 
  def validate(self):
22841 
    return
22842 
 
22843 
 
22844 
  def __repr__(self):
22845 
    L = ['%s=%r' % (key, value)
22846 
      for key, value in self.__dict__.iteritems()]
22847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22848 
 
22849 
  def __eq__(self, other):
22850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22851 
 
22852 
  def __ne__(self, other):
22853 
    return not (self == other)
22854 
 
22855 
class getRefundedOrdersMarkedPaid_result:
22856 
  """
22857 
  Attributes:
22858 
   - success
22859 
   - ex
22860 
  """
22861 
 
22862 
  thrift_spec = (
22863 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22865 
  )
22866 
 
22867 
  def __init__(self, success=None, ex=None,):
22868 
    self.success = success
22869 
    self.ex = ex
22870 
 
22871 
  def read(self, iprot):
22872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22874 
      return
22875 
    iprot.readStructBegin()
22876 
    while True:
22877 
      (fname, ftype, fid) = iprot.readFieldBegin()
22878 
      if ftype == TType.STOP:
22879 
        break
22880 
      if fid == 0:
22881 
        if ftype == TType.LIST:
22882 
          self.success = []
5411 rajveer 22883 
          (_etype546, _size543) = iprot.readListBegin()
22884 
          for _i547 in xrange(_size543):
22885 
            _elem548 = Order()
22886 
            _elem548.read(iprot)
22887 
            self.success.append(_elem548)
5208 varun.gupt 22888 
          iprot.readListEnd()
22889 
        else:
22890 
          iprot.skip(ftype)
22891 
      elif fid == 1:
22892 
        if ftype == TType.STRUCT:
22893 
          self.ex = TransactionServiceException()
22894 
          self.ex.read(iprot)
22895 
        else:
22896 
          iprot.skip(ftype)
22897 
      else:
22898 
        iprot.skip(ftype)
22899 
      iprot.readFieldEnd()
22900 
    iprot.readStructEnd()
22901 
 
22902 
  def write(self, oprot):
22903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22905 
      return
22906 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22907 
    if self.success is not None:
22908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5411 rajveer 22910 
      for iter549 in self.success:
22911 
        iter549.write(oprot)
5208 varun.gupt 22912 
      oprot.writeListEnd()
22913 
      oprot.writeFieldEnd()
22914 
    if self.ex is not None:
22915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22916 
      self.ex.write(oprot)
22917 
      oprot.writeFieldEnd()
22918 
    oprot.writeFieldStop()
22919 
    oprot.writeStructEnd()
22920 
 
22921 
  def validate(self):
22922 
    return
22923 
 
22924 
 
22925 
  def __repr__(self):
22926 
    L = ['%s=%r' % (key, value)
22927 
      for key, value in self.__dict__.iteritems()]
22928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22929 
 
22930 
  def __eq__(self, other):
22931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22932 
 
22933 
  def __ne__(self, other):
22934 
    return not (self == other)
5447 anupam.sin 22935 
 
22936 
class getAllVerificationAgents_args:
22937 
  """
22938 
  Attributes:
22939 
   - minOrderId
22940 
   - maxOrderId
22941 
  """
22942 
 
22943 
  thrift_spec = (
22944 
    None, # 0
22945 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
22946 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
22947 
  )
22948 
 
22949 
  def __init__(self, minOrderId=None, maxOrderId=None,):
22950 
    self.minOrderId = minOrderId
22951 
    self.maxOrderId = maxOrderId
22952 
 
22953 
  def read(self, iprot):
22954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22956 
      return
22957 
    iprot.readStructBegin()
22958 
    while True:
22959 
      (fname, ftype, fid) = iprot.readFieldBegin()
22960 
      if ftype == TType.STOP:
22961 
        break
22962 
      if fid == 1:
22963 
        if ftype == TType.I64:
22964 
          self.minOrderId = iprot.readI64();
22965 
        else:
22966 
          iprot.skip(ftype)
22967 
      elif fid == 2:
22968 
        if ftype == TType.I64:
22969 
          self.maxOrderId = iprot.readI64();
22970 
        else:
22971 
          iprot.skip(ftype)
22972 
      else:
22973 
        iprot.skip(ftype)
22974 
      iprot.readFieldEnd()
22975 
    iprot.readStructEnd()
22976 
 
22977 
  def write(self, oprot):
22978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22980 
      return
22981 
    oprot.writeStructBegin('getAllVerificationAgents_args')
22982 
    if self.minOrderId is not None:
22983 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
22984 
      oprot.writeI64(self.minOrderId)
22985 
      oprot.writeFieldEnd()
22986 
    if self.maxOrderId is not None:
22987 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
22988 
      oprot.writeI64(self.maxOrderId)
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 getAllVerificationAgents_result:
23009 
  """
23010 
  Attributes:
23011 
   - success
23012 
  """
23013 
 
23014 
  thrift_spec = (
23015 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
23016 
  )
23017 
 
23018 
  def __init__(self, success=None,):
23019 
    self.success = success
23020 
 
23021 
  def read(self, iprot):
23022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23024 
      return
23025 
    iprot.readStructBegin()
23026 
    while True:
23027 
      (fname, ftype, fid) = iprot.readFieldBegin()
23028 
      if ftype == TType.STOP:
23029 
        break
23030 
      if fid == 0:
23031 
        if ftype == TType.LIST:
23032 
          self.success = []
23033 
          (_etype553, _size550) = iprot.readListBegin()
23034 
          for _i554 in xrange(_size550):
23035 
            _elem555 = CODVerificationAgent()
23036 
            _elem555.read(iprot)
23037 
            self.success.append(_elem555)
23038 
          iprot.readListEnd()
23039 
        else:
23040 
          iprot.skip(ftype)
23041 
      else:
23042 
        iprot.skip(ftype)
23043 
      iprot.readFieldEnd()
23044 
    iprot.readStructEnd()
23045 
 
23046 
  def write(self, oprot):
23047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23049 
      return
23050 
    oprot.writeStructBegin('getAllVerificationAgents_result')
23051 
    if self.success is not None:
23052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23053 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23054 
      for iter556 in self.success:
23055 
        iter556.write(oprot)
23056 
      oprot.writeListEnd()
23057 
      oprot.writeFieldEnd()
23058 
    oprot.writeFieldStop()
23059 
    oprot.writeStructEnd()
23060 
 
23061 
  def validate(self):
23062 
    return
23063 
 
23064 
 
23065 
  def __repr__(self):
23066 
    L = ['%s=%r' % (key, value)
23067 
      for key, value in self.__dict__.iteritems()]
23068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23069 
 
23070 
  def __eq__(self, other):
23071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23072 
 
23073 
  def __ne__(self, other):
23074 
    return not (self == other)